{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "originalKey": "d160fbae-b6e1-4c88-a3c7-1f066923276c",
    "showInput": false
   },
   "source": [
    "## Gaussian Process Regression (with `GPytorch`)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "originalKey": "6d80a9e0-3153-4900-9aea-3d66a1d53038",
    "showInput": false
   },
   "source": [
    "This tutorial assumes familiarity with the following:\n",
    "\n",
    "1. Bean Machine [modeling](https://beanmachine.org/docs/overview/modeling/) and\n",
    "   [inference](https://beanmachine.org/docs/overview/inference/)\n",
    "2. [Gaussian Processes](https://en.wikipedia.org/wiki/Gaussian_process)\n",
    "3. [GPyTorch](https://gpytorch.ai/)\n",
    "\n",
    "A Gaussian Process (GP) is a stochastic process commonly used in Bayesian\n",
    "non-parametrics, whose finite collection of random variables follow a multivariate\n",
    "Gaussian distribution. GPs are fully defined by a mean and covariance function:\n",
    "\n",
    "$$\n",
    "f\\sim\\mathcal{GP}\\left(\\mu(x),\\mathbf{K}_f(x, x')\\right)\n",
    "$$\n",
    "\n",
    "where $x,x'\\in\\mathbf{X}$ are two data points (_e.g._) train and test), $\\mu$ is the\n",
    "mean function (usually taken to be zero or constant), and $\\mathbf{K}_f$ is the kernel\n",
    "function, which computes a covariance given two data points and a distance metric.\n",
    "\n",
    "The aim is then to fit a posterior over *functions*. GPs allow us to learn a\n",
    "distribution over functions given our observed data and predict unseen data with\n",
    "well-calibrated uncertainty, and is commonly used in Bayesian Optimization as a\n",
    "surrogate function to maximize an objective. For a thorough introduction to Gaussian\n",
    "processes, please see [1]\n",
    "\n",
    "With a PPL such as Bean Machine, we can be Bayesian about the parameters we care about,\n",
    "_i.e._ learn posterior distributions over these parameters rather than a point estimate."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Install Bean Machine in Colab if using Colab.\n",
    "import sys\n",
    "\n",
    "\n",
    "if \"google.colab\" in sys.modules and \"beanmachine\" not in sys.modules:\n",
    "    !pip install beanmachine"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "I0927 185346.164 _utils_internal.py:179] NCCL_DEBUG env var is set to None\n",
      "I0927 185346.166 _utils_internal.py:197] NCCL_DEBUG is forced to WARN from None\n"
     ]
    }
   ],
   "source": [
    "import copy\n",
    "import math\n",
    "import os\n",
    "import warnings\n",
    "from functools import partial\n",
    "\n",
    "import arviz as az\n",
    "import beanmachine\n",
    "import beanmachine.ppl as bm\n",
    "import beanmachine.ppl.experimental.gp as bgp\n",
    "import gpytorch\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "import torch\n",
    "import torch.distributions as dist\n",
    "from beanmachine.ppl.experimental.gp.models import SimpleGP\n",
    "from gpytorch.distributions import MultivariateNormal\n",
    "from gpytorch.kernels import Kernel\n",
    "from IPython.display import Markdown"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "originalKey": "b328d80e-b17d-4afc-a964-eef26a4cf388",
    "showInput": false
   },
   "source": [
    "The next cell includes convenient configuration settings to improve the notebook\n",
    "presentation as well as setting a manual seed for reproducibility."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pytorch version:  1.13.0a0+fb\n",
      "gpytorch version:  Unknown\n"
     ]
    }
   ],
   "source": [
    "# Eliminate excess UserWarnings from Python.\n",
    "warnings.filterwarnings(\"ignore\")\n",
    "\n",
    "# Manual seed\n",
    "torch.manual_seed(123)\n",
    "\n",
    "# Other settings for the notebook.\n",
    "smoke_test = \"SANDCASTLE_NEXUS\" in os.environ or \"CI\" in os.environ\n",
    "\n",
    "# Tool versions\n",
    "print(\"pytorch version: \", torch.__version__)\n",
    "print(\"gpytorch version: \", gpytorch.__version__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "originalKey": "a39b60c5-e262-4f6b-a6d3-43bef3585ea5",
    "showInput": false
   },
   "source": [
    "Let's use some simple cyclic data:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "bento_obj_id": "139891732995952",
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "x_train = torch.linspace(0, 1, 11)\n",
    "y_train = torch.sin(x_train * (2 * math.pi)) + torch.randn(x_train.shape) * 0.2\n",
    "x_test = torch.linspace(0, 1, 51).unsqueeze(-1)\n",
    "\n",
    "with torch.no_grad():\n",
    "    plt.scatter(x_train.numpy(), y_train.numpy())\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "originalKey": "5782e71f-768e-43ec-9664-fe3555b7f00b",
    "showInput": false
   },
   "source": [
    "Since this data has a periodic trend to it, we will use a Periodic Kernel:\n",
    "\n",
    "$$\n",
    "k(x,x')=\\sigma^2\\exp\\Big(-\\frac{2}{\\ell}\\sin^2\\Big(\\pi\\frac{|x-x'|}{p}\\Big)\\Big)\n",
    "$$\n",
    "\n",
    "where $p$, $\\ell$, $\\sigma^2$ are the periodicity, length scale, and output scale of the\n",
    "function respectively, the (hyper)parameters of the kernel we want to learn."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "originalKey": "99ad8c77-7a08-47b6-8f40-4a360870d483",
    "showInput": false
   },
   "source": [
    "## Maximum Likelihood Estimation (with GPyTorch)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "originalKey": "2685a4bf-ada5-4f01-b175-9c058f47488b",
    "showInput": false
   },
   "source": [
    "GPytorch's exact inference algorithms allow you to compute maximum likelihood\n",
    "estimates (MLE) of kernel parameters. Since a `SimpleGP` extends a GPytorch ExactGP model, you\n",
    "can use GPytorch to optimize the model. Let's try that, closely following the\n",
    "[GPytorch regression tutorial](https://docs.gpytorch.ai/en/latest/examples/01_Exact_GPs/Simple_GP_Regression.html)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "Regression = SimpleGP"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "kernel = gpytorch.kernels.ScaleKernel(base_kernel=gpytorch.kernels.PeriodicKernel())\n",
    "likelihood = gpytorch.likelihoods.GaussianLikelihood()\n",
    "mean = gpytorch.means.ConstantMean()\n",
    "gp = Regression(x_train, y_train, mean, kernel, likelihood)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iter 1/100 - Loss: 1.082\n",
      "Iter 11/100 - Loss: 0.504\n",
      "Iter 21/100 - Loss: 0.040\n",
      "Iter 31/100 - Loss: -0.385\n",
      "Iter 41/100 - Loss: -0.755\n",
      "Iter 51/100 - Loss: -0.939\n",
      "Iter 61/100 - Loss: -0.947\n",
      "Iter 71/100 - Loss: -0.966\n",
      "Iter 81/100 - Loss: -0.960\n",
      "Iter 91/100 - Loss: -0.954\n"
     ]
    }
   ],
   "source": [
    "optimizer = torch.optim.Adam(\n",
    "    gp.parameters(), lr=0.1\n",
    ")  # Includes GaussianLikelihood parameters\n",
    "mll = gpytorch.mlls.ExactMarginalLogLikelihood(likelihood, gp)\n",
    "gp.eval()  # this converts the BM model into a gpytorch model\n",
    "num_iters = 1 if smoke_test else 100\n",
    "\n",
    "for i in range(num_iters):\n",
    "    optimizer.zero_grad()\n",
    "    output = gp(x_train)\n",
    "    loss = -mll(output, y_train)\n",
    "    loss.backward()\n",
    "    if i % 10 == 0:\n",
    "        print(\n",
    "            \"Iter %d/%d - Loss: %.3f\"\n",
    "            % (\n",
    "                i + 1,\n",
    "                100,\n",
    "                loss.item(),\n",
    "            )\n",
    "        )\n",
    "    optimizer.step()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 288x216 with 1 Axes>"
      ]
     },
     "metadata": {
      "bento_obj_id": "139891724235344",
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "with torch.no_grad():\n",
    "    observed_pred = likelihood(gp(x_test))\n",
    "    # Initialize plot\n",
    "    f, ax = plt.subplots(1, 1, figsize=(4, 3))\n",
    "\n",
    "    # Get upper and lower confidence bounds\n",
    "    lower, upper = observed_pred.confidence_region()\n",
    "    # Plot training data as black stars\n",
    "    ax.plot(x_train.numpy(), y_train.numpy(), \"k*\")\n",
    "    # Plot predictive means as blue line\n",
    "    ax.plot(x_test.squeeze().numpy(), observed_pred.mean.numpy().T, \"b\")\n",
    "    # Shade between the lower and upper confidence bounds\n",
    "    ax.fill_between(x_test.squeeze().numpy(), lower.numpy(), upper.numpy(), alpha=0.5)\n",
    "    ax.set_ylim([-1, 1])\n",
    "    ax.legend([\"Observed Data\", \"Mean\", \"Confidence\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "originalKey": "a66e8e17-8b9c-4889-8955-3db972595db5",
    "showInput": false
   },
   "source": [
    "Not bad! Our GP fits this simple function fairly well. However, we've only captured data\n",
    "uncertainty, not parameter uncertainty. It can often be the case that calibrating\n",
    "parameter uncertainty may lead to better predictive performance. In the next section,\n",
    "we'll do just that using Bean Machine's NUTS algorithm."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "originalKey": "02844063-d2f7-41a3-84ad-6614a66c2ed4",
    "showInput": false
   },
   "source": [
    "## Fully Bayesian Inference with Bean Machine"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "originalKey": "549a3598-a327-4670-9e82-e017d96d5129",
    "showInput": false
   },
   "source": [
    "Let's reuse the same model, but this time, use Bean Machine to learn posteriors over the\n",
    "parameters. In `train` mode, `SimpleGP` is a simple wrapper around\n",
    "`gpytorch.models.ExactGP` that lifts the model's `__call__` method to BM.\n",
    "\n",
    "As before, we'll create kernel and likelihood objects.\n",
    "This time, we'll include priors\n",
    "on our parameters $p$, $\\sigma^2$, and $\\ell$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [],
   "source": [
    "from gpytorch.priors import UniformPrior\n",
    "\n",
    "\n",
    "mean = gpytorch.means.ConstantMean(constant_prior=UniformPrior(-1,1))\n",
    "kernel = gpytorch.kernels.ScaleKernel(\n",
    "    base_kernel=gpytorch.kernels.PeriodicKernel(\n",
    "        period_length_prior=UniformPrior(0.05, 2.5), lengthscale_prior=UniformPrior(0.01, 0.5),\n",
    "    ),\n",
    "    outputscale_prior=UniformPrior(1.0, 2.0),\n",
    ")\n",
    "likelihood = gpytorch.likelihoods.GaussianLikelihood(noise_prior=UniformPrior(0.05, 0.3))\n",
    "\n",
    "gp = Regression(x_train, y_train, mean, kernel, likelihood)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "originalKey": "27c025ca-fe91-4e85-83e8-825924ff4946",
    "showInput": false
   },
   "source": [
    "Now we can run inference as we would with any other Bean Machine model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "6d1eda1f16754e2f9aa64efe1120f504",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Samples collected:   0%|          | 0/100 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from beanmachine.ppl.experimental.gp import make_prior_random_variables, bm_sample_from_prior\n",
    "\n",
    "\n",
    "num_samples = 1 if smoke_test else 100\n",
    "num_adaptive_samples = 0 if smoke_test else num_samples // 2\n",
    "num_chains = 1 if smoke_test else 1\n",
    "\n",
    "name_to_rv = make_prior_random_variables(gp)\n",
    "@bm.random_variable\n",
    "def y():\n",
    "    sampled_model = bm_sample_from_prior(gp.to_pyro_random_module(), name_to_rv)\n",
    "    return sampled_model.likelihood(sampled_model(x_train))\n",
    "\n",
    "queries = list(name_to_rv.values())\n",
    "obs = {y(): y_train}\n",
    "\n",
    "nuts = bm.GlobalNoUTurnSampler(nnc_compile=False)\n",
    "samples = nuts.infer(\n",
    "    queries=queries,\n",
    "    observations=obs,\n",
    "    num_samples=num_samples,\n",
    "    num_adaptive_samples=num_adaptive_samples,\n",
    "    num_chains=num_chains,\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "originalKey": "f85b804d-1bbf-4e05-96cb-0c9fb88cb189",
    "showInput": false
   },
   "source": [
    "Let's take a look at how our model fit. We will plot the samples of our posterior as\n",
    "well as the predictives generated from our GP."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Shape validation failed: input_shape: (1, 100), minimum_shape: (chains=2, draws=4)\n"
     ]
    },
    {
     "data": {
      "text/markdown": [
       "|                                                |   mean |    sd |   hdi_3% |   hdi_97% |   mcse_mean |   mcse_sd |   ess_bulk |   ess_tail |   r_hat |\n",
       "|:-----------------------------------------------|-------:|------:|---------:|----------:|------------:|----------:|-----------:|-----------:|--------:|\n",
       "| kernel.base_kernel.lengthscale_prior()[0, 0]   |  1.223 | 0.484 |    0.453 |     2.068 |       0.059 |     0.043 |         71 |         78 |     nan |\n",
       "| kernel.base_kernel.period_length_prior()[0, 0] |  1.715 | 0.38  |    0.985 |     2.346 |       0.049 |     0.035 |         53 |         27 |     nan |\n",
       "| kernel.outputscale_prior()                     |  1.447 | 0.265 |    1.009 |     1.876 |       0.04  |     0.028 |         46 |         55 |     nan |\n",
       "| likelihood.noise_covar.noise_prior()[0]        |  0.092 | 0.047 |    0.05  |     0.184 |       0.006 |     0.004 |         21 |         21 |     nan |\n",
       "| mean.mean_prior()                              | -0.033 | 0.574 |   -0.982 |     0.881 |       0.09  |     0.092 |         39 |         34 |     nan |"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "execution_count": 74,
     "metadata": {
      "bento_obj_id": "139879472823264"
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "summary_df = az.summary(samples.to_inference_data())\n",
    "Markdown(summary_df.to_markdown())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [],
   "source": [
    "lengthscale_samples = samples.get_chain(0)[name_to_rv['kernel.base_kernel.lengthscale_prior']]\n",
    "outputscale_samples = samples.get_chain(0)[name_to_rv['kernel.outputscale_prior']]\n",
    "period_length_samples = samples.get_chain(0)[name_to_rv['kernel.base_kernel.period_length_prior']]\n",
    "mean_samples = samples.get_chain(0)[name_to_rv['mean.mean_prior']]\n",
    "noise_samples = samples.get_chain(0)[name_to_rv['likelihood.noise_covar.noise_prior']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjgAAAFgCAYAAAC2QAPxAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nOzdd3wb5f3A8c9peY94xdkDQkIGhJRNCPMYV9YxuhltoUChLQXKKi2UPVqgpVBo4QctUGhpEVMMQUgIUAgjJCEhm0zHiUfirXn3+8PnWJKHJFte8vf9evll+3R3enSWpa++z/d5HsU0TYQQQggh0oltoBsghBBCCJFqEuAIIYQQIu1IgCOEEEKItCMBjhBCCCHSjgQ4QgghhEg7EuAIIYQQIu04BroBQvQ1VdNvBm7q5KbdwEfAbV6P+4MBaFqPqJq+AJjo9bgn9uF9XAA8EW8/r8et9FUbYqma/iRwfrz7jPh7T/J63BtT3Ia263KM1+Ne0M1+sfNv+IGdwGLgSa/H/WrM/kcD7wI/9HrcT6ayzdb5JwJfA7/zetw3R7Tx716P+4JU31/E/fb5fQjRFQlwxHByNrDJ+tkB7A1cDSxQNf1Er8c9P9V3qGr6gcAnKQ4ELgZcKTxfd34O/K+f7iuem4E/J7DfX4FXgYp+aFN33gJ+bf2cCUwCzgJeUTX9ReC7Xo/bZ93+GXCQFYQkTNX0PwO5CQQQFdb5++yaqJp+NXCK1+M+OmLzQUB1X92nEN2RAEcMJyu8HveqiN8/UjX9NWAdcBtweB/c55GpOpGq6Rlej9vv9bhXp/J8cXZb6/W4P03F/fWWlY3pMiMTcX0qBkFwA7Ar5tq9Dzylavp3gWeAB4GLaH1sDUBPrvORwJKublQ1XQGcXo870MPzJ9uWKIPluSOGJwlwxLDm9bh3qZr+P+BEVdMVr8dt0vrGcAZwLbAfoAArgfu8Hvc/245VNX20FRgdD5QBtcB84Hqvx73F6ko6ivZU/cK2T7eqpp8A/AY4wDr/UqurzBNx/gVAIXAH8EdgFXBMZ11UqqYfaXXLHGxld9YBfwP+FPGYngTOAE4H2rpBJqXiOqqa/gxwnPUm95j1yX0XcK/V9uuBnwL5VkboQq/HvcU69p/AN4HZwCPAEUDYysL8zOtx19JJF1VEV9QR1mOdBtg766JSNX0CcI/1t3IBy4CbvR63N+IxzAR+ZwW6hcBm4CngHitASAmvx/2squnHAT9SNf0er8e9trMuKlXTTwJuAGYAWVZw96R1TSdEZHv2UzX9fOCHwAJr+9XW9TwbuNR6zkR1UUU87u8CvwUmA9uAP3g97oeI7tq62+txXxdxTFSXV2SXnPVz5PaoLipV0y8ELgemAiErQLvN63G/FbHPNut6PAr8AZgFVFl/j996Pe5wqv4eIn1JkbEQrS+ye7qQVE3/NuAG6oDvWW8SW4BnVE3/ccRxL1pvhlcBxwK/Ag4F3rI+OV9svUljveFfbJ3/FOB1KyA6x/qqBl61bouUbQUHlwJXdtZ4VdPnAu8ABcCPgVOBD4EHgFtidleAu6zg6jupuoDWNXRa9SlPAKdZb8j3A48D+wLnWfd7fExXUxDIBZ4FXgE04D6rfU8lcN93Aw9Zf4MOVE0vtLIns63reBqwHfComn6MtU+x9YY6DbgMONF6DtxqBT2p9qT1+vvNLtq8P/AysAH4ltWe/1jB7nURXU5Yz7GDrGvX5tvWB1jN6irrykFWEHWzFfiuA/6sarqe5OM5yLqmn1s//7WLx3WNFYyuAM60nhMAr6uarkbsGrK6kB+yngsnAAuttl6UZNvEMCUZHDGsqZqeARwIfNGW6QBut7Il32z7pKhq+uvAF9Yn3cdVTR9hvZBf4fW4n7eO+1DV9OXWG3ie1+NerWp6DR1T9fdaGQTd63Eb1vnfApZbb6aRBahTAM3rcb/ezcP4HdAAHGt1dQB4VU0vB65UNf1ur8fdaG3PB/7h9bifTtU1tJhAEfBI27mtT+9vA4cB063rO1/V9LNjujNM683+X16Puy3weU/V9LHAhaqmj2vL9nThQ6/H/XA3t/8UGAtMa+veUzX9A2AtcK4V2Ey2gqAHvB73wog2nGAFudf3+gpF+9L6vk8Xtx9rBYy/8Hrcdda2RaqmrwUa27qcVE0HqGl7fqmanmftOxY4LOL521VB+l5Wpmu7td97VqByqRXgJcTrcX+qanoAaOiqW0rV9GzgRsDr9bi/H7H9DSsY/g3QllEzrf+vmV6P+ytrvy+sv8XxVqZPiG5JgCOGJVXT7daL+63AGOBn1vbx1vZ7I9PgXo/bVDXdA1xndXdst0ZhXaxq+ufAB16P2/B63Mus4KWr+x1nZQnubAturPOHVE1/Fbha1fSCiDe1tiChq/M5gbnASxHBTZvXrGzON6xPv226+0Qf63XrTbQzv/F63LfFbHsz4ufN1vf5EcFj2/YjOjnfyzG/vwtcaHXjdRfgxHs8xwNbI2uXrABhQsTvnwCdPdD1VuYn1Zqs7zld3L7N+n6Pqum3tQV4Xo87kYwWwDsJduMsbgturPM3q5q+2HrOpNqBQJ6V+dzD63G3qJo+HzhL1XSn1+MOWjetbQturP0aVE3fZQXSQsQlAY4YTr7q5M16G3Cu1+Nu+7Q6xvre2RtqW+HqKK/HvcnqyvoH8B6wS9V0r9WN8N/I4CXGWOv79aqmd5UVGGV1j2EVqga72A+gxKop6ba9Mdt3dnO+WJdZ3V2d2R67wetxV0X82tbuqpjdgpFdghG2dtHOkjhtjPd4xgA74uyDqumXW118+1hdg32p1PreVduft4LAy4CfqJr+ldWt+YTX4/6yi2MiJfo37ux5swMosj4EpFK8/y0nUAxURrQjVkhKK0SiJMARw4keMQrHtIKITTHZhbafuxuGbdL6Zv6Wlc05HjjZ+vqWlfX4Zsx5Y89/Xzf1JZsifu4uuEmqvUmcM9IGr8f9RRL790ZsxqEtCOrsOkZK5PFkdHejqumXWKOaXrSGdu+w2nOXVf+Saoda31d0dqP13PmFqul3W1m4E6waritUTT83sti9C4n+jTu7tole92Ql+1xN9f2LYUYCHDGcrIoZJt6ZtizCmE5ua8u+tHUfYA2zfs36QtX0X1sjq+bFdAu1afv0aktR4FAN+BJt7yA3KubTfZn1PW72JY6twOzIUXK0/q1yALvX464HfmBlpM6KzL5ZNVp94SdAILa7JpY15P1R4FGr7ustq0YsXoCTqNjsHsBIoMrrcRuqprddi9isycge3Fe8/y0fUNOD8wrRKUn1CRHB63FvtQqMz4hM0auabrNGpKz2etxbVU0/UNX0J6w3yUivWd/buiDahmjbrfNvA74CvhX75qlq+q+sTEIy7Q1ZQ4NVVdPzY24+1aoTGipzkcSOKDoGMFLQ/nesuo15bRusv+dy4N/Wplxgd0xwM7utGDqV3TWqpl9pZYVu93rcu7vY5zJV06+K3Ob1uHcBH0Q8t9r0pm2Hqpq+p6bFej4fbM24jPX8ARgdc9zxnZzLjNOWT63znR250So+PtaaRiHU40ciRAzJ4AjR0Q3Af4GXVU1/2HrR/ok1H8lZ1j47rJ8nq5r+R+vTf7k1VLzGmg+HiDqV61RNX+H1uF+0hvm6gbdVTb/PetE/w5o1+Kou2tSdm606oLesLo0W4LtWl9kVEbPl9sQUVdO7m4l2Q9s8NSlwiarpWda8KEdZ87r82+txJ1Mz1Jm/WKOC/qlq+rVWRusnwHjrO1aQ+AtV06+zRlMdYN32mNU1dKGq6S8leb8jrJmssepLJlqjtk62uifv6OZYh1VgPBJ4w8r2zAZ+ZNXntNkOHK1q+resId7J/i2+tp43dwLN1vMvr20Yv9fjrlc1/TPgdGsY9yorGDmhk3NttzJlP7C6fhdF3uj1uH2qpv8OuF/V9L9bkx3mWXP25FsjFIVIGcngCBHDKjg+wyp4fN6an2WENQ2929pni5Vh2A08bL1B/smat+SIiDf9R61J/G5oC168HvfLVjbItN7oXrFGQv3Y63Hf14P2fmxNstdkne9Fa2K0870e9x97eTn+BHzSzZfWy/NHOgc4yRom/0urgPsnCRzXLSvzcSSwyHo8r1jBxje9HnfbCLWbgKetANVjBSFnWpPMrQPu7GLkV3dOiLhOH1jnwpoe4LzushXW3+1yK1PitoKcS612RGb5brAKoh9OZtZsa/QdVnbrfqvb60Vr4scLvR73GxG7f88qNH/eGt5+irUNK3Brc4s1XcGfrexhZ4/rAauQe7Y1au4J65ijvB734s6OEaKnFNOUOi4hxMBJdBFNIYRIhmRwhBBCCJF2JMARQgghRNqRAEcIIYQQaUdqcIQQQgiRdtJ5mHjaRG61VZUUlZYPdDMGNblG8ck1ik+uUXxyjeKTaxRfiq9RpwMUpItqCDDCXS1rJNrINYpPrlF8co3ik2sUn1yj+PrjGkmAI4QQQoi0IwGOEEIIIdKOBDhCCCGESDvpXGQshBBC9DnTNKmtrcUwWutKfIEQVVVVA92sQa0n18hms1FUVISiJDbpuQQ4QgghRC/U1taSk5NDZmYmAMFgAKfTNdDNGtR6co18Ph+1tbUUFxcntL90UQkhhBC9YBjGnuBG9J3MzMw9WbJESIAjhBBCiLQjAY4QQggh0o7U4AghhBAp9MwnYez2QMrOd+4h3deqvOmdz8ZNm7n4wgt6dT9Nzc18tWoNB86ZzT+efo78gnzOOFXr1Tkj9cU5uyMZHCGEEEKwbt0GPvv8i4FuRspIBkcIIYRIAy+94mHBe+9jGCZHHXk4Z55xKk/+45+0+Hxs2bKVbdsrufySCznowDn863k38xe+x5jRowgGQ5x5+ik89MhjNDc3M3bMaAA2btzEr2+6ja1bt3H5pRdx0IFzeOiRx1izdh1+f4BTtBM5RTuR+QsW8eLLr2IYBmfrp3P0UXP5zwsv8d77H2IaJgcf9A3O/f63o9r696eeY+Wq1YTDYfTTTuHoo+am/HpIgCOEEEIMcfX1Daxbv4H77rkdgCuuvp65RxyGzWZj584q7rj1tyz+5DNee/0tpk3dh1c9b/D4ow/S0uLjgot+ytn6aZxz1hls3LSZb558Av94+jnq6xu4/Xc38smnn/Pa628xdeoUPlr8KU/93yMEgkFef8NLS0sLTz/7Lx558D4CgSD33PdHjj5qLiZw75234HK5OO/Hl3Kmfuqetn65YiU7q6u5757bCQQC/PTnV3P4YQfjcqV2aH2/Bziqpk8CngCOAiZ5Pe6NCR53BPAecKvX476571sqhBBCDA3Lv1xBMBji6ut+A0Bzcws7duwEYNbM6QCUlpbQ2NRExfZKxo8fh8vlwuVysdfkSZ2ec+aMfQEoKSmmsamJ/Lw8RpWP5KZb7mTuEYdx0gnHsXnLVkaXl+851y2/vQEAh93OdTf+DpvNRl1dHQ0NjXvOu3rNOlatWsNV194IgGEa1NTuYlT5yJRek34NcFRN14FHgDeSPC7LCooaE9hdCDEAXqiu7rNzn1lS0mfnFiJdHHTgAVz5i8uiti35Yhk2u33P76ZpAiaRcwF3NTNwx+Pg7ttvZtXqtbzz7kJefvV1fn7ZTzCs29ps317Jiy+/xl8evI/s7Cx+dPHlHc6tHnc0537/Oz1+rIno7yLjImAe8FSSx90BrAKW9FG7hBBCiCFrv1kzWLp8BT6fH9M0eeiRx/D7/Z3uWz5yJJu2bCUYDLJr127Wr/8aAJtNIRwOd3kflTt28tKrr7PvtH249Cc/omL7dkaPKmfbtgpafD4CgQDX3HATDY1NFBYWkJ2dxcpVq6muriEUDO45z7Sp+7D4088Jh8MEAgEeeuSxPrgi/ZzB8Xrcj9OakRmX6DGqps8FzgVmAc/2aQOFEEKIXvr+QfZ+X6ohLy+Ps844lauuvRFFgcMPO4SMjIxO9y0oyOfYo47k8iuuYfKkiUydOgW73cbee03msSeeoqy084xpcdEIVqz8igULF2EYBt/51lnk5ORw/rnf45rrb8I0DfTTT2GvyRPJyc7ml7+6genTpnLaKSfz50ceY/q0qQDMmD6N/WfN5IqrrsfE5BTtpD65JooZk1rqD6qmHw9449XgqJqeDSwFfuf1uJ9WNX0BsCCRGpzaqkrTCCc+pfNgFgoFcTicA92MQU2uUXx9fY08Tc19dm4tJ7vPzh1JnkfxyTXqqCUQonxUefsG04QEF4QcKN53FnD0vLnYbDYuv+JX3HrzrykpLuq/BvTwGlVuryTLFZ2bKSkf3emJBvsoqjuAlV6P++lkDywqLU9gr6GhurKCkvLRA92MQU2uUXx9fY1y+7AGp6SfanDkeRSfXKOOqqqqojI2Q2GxzfqGRq685kacDgfHH3s0o8r79z2zp9coMyuLktLShPYdtAGO1TX1PWC/gW6LEEIIkU6+c86ZfOecMwe6GX1q0AY4wI+BfOBLVdPbthUAB6uafprX454zsM0TQgghxGA1qJZqUDX9TlXTn7F+vRLYG5gd8fWpNcy8fxayEEIIIcSQ1N/z4KwGJkQEVqtVTTeBp7we90XAKOt2vB73LmBXzPF+oN7rcVf2Z7uFEEIIMbT09zDxqXFu73YpVK/HfXTKGyWEEEKItDOYa3CEEEKIIefF2lrs9tS9vaZyJu/33v+QeXMP77fjYv3ggp/wt7/8EYfDnsDevTOoanCEEEII0TdCoRD/db/cb8cNNMngCCGEEENYKBTi/j/9he3bKwmGQpx/7nd54E8P87e//JGsrCwefexJJk4Yz+o1a/l64yb+9NCjTNl7Lz79bAktPh9VVdWcpZ/GSScctyfD0tVx3znnTO68934UFELhENdefQVlpSXc/6eH2bGzCpuicO3VV5CVncWdd9/XuoSDP8Bll17ItKn77GlzTU0tD/7lMQKBAHa7nSt/cVmXMyj3lAQ4QgghxBD27sJFOJ0O7rv3dmpqa7nymhs73e9bZ+usWr2Wn192MW9657N1WwUP/+n3NDU3c8llv+RE9di4x/3nhZeYc8D+nPu9b7N6zVpqa3ex8qtV5Ofnc81Vv+DdhYv48KPFzDlgf44/9miOPmouS5d9yb+ed3PTjdfuOedT//w3Z+mnMWf2fny8+FP++dzzXPGzS1N6XSTAEUIIIYawNWvXc8D+rXPiFhcV4bDb2b1rd9zjZkyfht1uJz8vj+zsbOrrG+IeM+eA/bnp1rtoampm7uGHMmvmdN57/0NmzZwOwDFHHQlAfUMD//v4E15+9XX8gQCZmdHrYq1dt55tFdt55tl/YxgGhQUFPXz0XZMARwghhEgjJib5+Xl7fu9uhfA9x5gmigJKxPpQnR03edJE/vrQ/Xzy2RIe+dv/caJ6XOvxRvS6lu6XXqWkuIjrr/klX61aw2NP/KPDuW687mpKSoqTfnyJkiJjIYQQYgibus/efP7FUgB27qwCIDunPSOzbt0GAGyKQthoD1pWfrWacDhMfX09fr+fvLy8uMe9u3ARm7dsY97cwznnrDNYs3Yd+0zZi6XLvwTgo48/4ZnnnqehoZHRo0eBNQIrFArFtHkKH360GIAlXyxj/oJFKb8uksERQgghUuiMoqJ+XWzz6HlzWfLFcq781a8JG2GuuPxStm6r4NY772XypImUlBRjmgZFRSMIBUPcdufvOejAOZSVlfCbm2+nuqaWC877HoqicPopWrfHffscnQcf/isul4tQKMTPfvoTxo8by+dLlnHlNb9GsYqMd++u4+7fP8CiD/7H6adqfPi/j/G+8+6eNn//O2dz/4OPsGDh+6DAr678ecqvi2KaZgK7DUlp88Bk9d745BrF19fX6IU+XE08lfOAdEeeR/HJNeqoqqqK0ogVrofCauJveuezcdNmLr6w2/l1+0xPr1HstbYone0rXVRCCCGESDvSRSWEEEIMM10NCU8nksERQgghRNqRAEcIIYQQaUcCHCGEEEKkHQlwhBBCCJF2pMhYCCGESKG1nibsdn/Kzjf1lLwE9kpObe0u/vHMcwmt/9TS0sJFl/6Cp5/8a9RinL314UeLOegbB+B0OjnrO+fx3+c6znbcG5LBEUIIIYaZESMKU764ZbL+6365wwzHqSQZHCGEEGIIe/3Nt/n0syW0+HxUVVVzln4aY8eM4v+efAab3UZZaQlXXXE5b89fyOJPPqOmtpYLf3guDz/6fzz8p9+zdNmXPP7kUzjsDkpLS7jql5cTDAa55fZ7CAQCzJwxvcN9VtfUcv+fHiYQCGC327nyF5dRXDSCH/3kco44/BCWL19JXn4et938a2pqa7ntzt/jdDqZOWNfli1bwQnqMXy1ag03/PZW7rnjdwA88fdn+GzJF+Tn53Pbzb/GZutdDkYyOEIIIcQQZrPZWpdmuOkG/nDPbfzj6Wd5+NHH+d1vr+f3d91KYWEBCxd9CEB1TQ3333sHJRGzgz/w4F+48bqrue/e28nLy2X+uwt5Z/5CJk+ayP333sHee03qcJ9/f+pZztJP4947b0E/7Zv887nnsdvtbK/cwfHHHs2DD9xDQ30DX2/cxIsvvcbR8+by+7tuxTRMFJvCccfMo2hEIXfc8hucTicNDY0cNe8I/vzAvTQ0NPL1xk29vi6SwRFCCCGGuBnTp2G328nPyyM7O5stWyu4+ba7APD5/BQWFFBQUMA+U/aOWjG8vqEBm81GWVnr8gezZkzny5VfYRgG+82aAbDne6Q1a9exZetWnnn23xiGQWFBAQDZ2VlMnjQRgNLSEhqbmti0eQvzjjwcgDlz9ufLlV91OF/UcSXFNDY19fqaSIAjhBBCpBHDWiDzD3ffFrX9Te98HI7u3/ZN00RRlD3fAUyj86Udb7zuakpKiqO22e32mBO2LQzZei6b0nnHUWfH9ZZ0UQkhhBBD3MqvVhMOh6mvryfgD2BTlD3dPC++/Bobvt7Y6XH5eXmYpsmOHTsB+GLZcvaZshfjxo5h7dr11rYvOxw3beoUPvxoMQBLvljG/AWLumzb6FHlrFm7DoBPPvt8z3bFZiMcNnr1uLsjGRwhhBAihaZoOf2+mnhZWQm/ufl2qmtqueC871E+soz7HngIu8NOaUkJ2sknsHbdhk6P/cXPLuH2u/+A3W5nzOhRHHPUkbS0+Lj5trv41fW/ZdaM6RhmdErl3O9/h3vv+xMLFr4PCvzqyp932Tb99G9yy+338v6HH7HvtH32ZGv2nzWDq669cU+RcaopppmCPNDglDYPrLqygpLy0QPdjEFNrlF8fX2NXqiuTtm5msJhdgaD+A2DkGkyNz+fUpeLkU4npU5nVA1BKvXH82j1qw19ev7eSGS+Fflf66iqqorS0tI9vweDgX4NcN70zmfjps1cfOEF/Xafydi4aTONjU3MnLEv8xcsYtnyL7nskh/36BrFXmtLpy8IksERQgw40zTZFgjwRWMjX/t81IfDUbe/VFOz5+dih4NZOTkcnJfH0YWFjHT17ydlIURysrOy+OOfH8E0TWw2W7fZnlSSAEcIMWBM02RNSwvv1dWxMxhM6JiaUIgFdXUsqKvjnq1b2S8nB72khBNGjCCzl/NmCDEUnageO9BN6FZZWSn333tH1LZgMNDn9ysBjhBiQDSGw3hqa1nb0tKr8yxramJZUxMPbN3Kt0tL+V5ZGXlxRooIIdKfvAoIIfrdNr+f/1RX0xjTFdXGBpS5XOTZ7TgVhWKHg53BIJv8fnxG56Mu6sJh/lpZybNVVZw3ciQ/KCvDJRkd0Q9sNhs+n4/MzMyBbkpa8/l8Sc1uLAGOEKJfrW9p4T/V1YRiBjgowJSsLGbn5jIpMxNHRCHxmdasqyHTZG1LC4vr65m/ezdfNjd3OH9DOMxDFRW8WlPDdePHc3Be6hcqFCJSUVERtbW1NDS0FpD7WlrITMFilOmsJ9fIZrNRVFSU8P79HuComj4JeAI4Cpjk9bg7H5zfuu9I4G7gJCALWAHc4PW4F/Rvq4UQqbDJ5+P5qipi8zZjXC60oiLK4hQMOxSFfbOz2Tc7m/PLy9ni8/Hf6mpeqqnpUJi8ye/n0rVr+W5pKT8fM6bTbE7syK/GpmZyUzQa7MyIqfBFelMUheLi9gnvqisrKOk40kdE6I9r1K/5W1XTdeAjINFFJl4CRgKzre8LgVdVTZcxikIMMTXBIP+pru4Q3Byal8d5I0fGDW46My4zkyvGjuWVmTP56ahR5MfOhgo8W1XFBatXs8Xv70XrhRBDTX93UBcB84Cn4u2oanq+lbH5pdfjrvR63D4rm5MDHNo/zRVCpEJLOMy/q6o61M+cMGIEx40Yga2X89rk2u38eNQo3DNmoBcXd7h9dUsLF6xezfIUrG8jhBga+rWLyutxP05r8DIugX3rgR/HbJ5sfa/okwYKIVLONE1era2lNhSK2n5UQQEHpbg+ptDh4MYJEziluJjfbNxIRaB9KOruUIiL16zhrsmTmWctDCiESF9DpsjYyug8Abzm9bg/ird/bVUlRh+ucdGfQqEg1ZUS03VHrlF8fX2NGps6FvwCrAoEWRMzFHxfp5P9TYPGut0Jnbs6lNycGWOBB4sKuX93He/72rum/KbJ1evXc3PRCA7OzOjQ5rARTrhNPW1zY33nI8cGg+rK+LMsy/9afHKN4kvlNepqZu0hEeComj4BeBXYCXw3kWOKSsv7vmH9RKZGj0+uUXx9fY06K85tCIdZuH171LbRLhenjRwZNUoqnpIeFOyWAA+MGsNftm/n8crKPdvDwG27dvPQlCnkOqLrfhrrdpNbUJj0fSXT5pr8wbtUQ0m5LNWQCnKN4uuPazToJ4lQNf0gYDHwAXCS1+MevK8OQogob9bWRtXd2IFTi4uTCm56Q1EUfjp6NNeNGxe1WI3fNPnFunXsDPT9bKpCiIExqDM4qqbPBN4AbvF63H8c6PYIIRK3yedjdUzX1FGFhZQ4nf3elnOs4ah3bdmyZ1uTYfDf6mp+VF5OhkwIKETaGVT/1aqm36lq+jPWz3bg78DDEtwIMbSYpsn83dG1LKNdLg4ZwEn3zikt5bLR0Snx2lCIV2pqMGMmHRRCDH39msFRNX01MCEisFqtaroJPOX1uC8CRlm3AxwGzAFmqpr+qzb4wsoAACAASURBVJhTte0vhBiEVre0RI1gAlBTMBy8t344ciRb/f6o1clXt7SwuKGBQ/LzB7RtQojU6u9h4lPj3H5BxM/vW7O3CyGGkLBp8m5M9mZqVhZjMzIGrE1tFEXh2nHjWN3czKqI7rN3d+9m76wsBr6FQohUGVRdVEKIoW9lc3PUnDcKcHRhakYmpUKGzcY9kydHzXocBl6trZWuKiHSiAQ4QoiUMU2Tj+vro7btn5MzIIXF3RmTkcE146LnG93q97MsEBywNgkhUksCHCFEymzy+9kRjA4SDh+ktS0njRjB3pmZUds+8PloiJlxWQgxNEmAI4RImdjszdSsLEYMsuxNG0VROLmoCFdE4XMQWFhXN6DtEkKkhgQ4QoiUqA4GWefzRW0b7COT8h2ODvVBS5ua2CETAAox5EmAI4RIiU8boicZH+1yMdbl6nL/wWJObi7FjugBpbFz+Aghhh4JcIQQveY3DFY0NUVtOzgvD2WA571JhF1RODYmi7PB52NDzCzMQoihRQIcIUSvLdy9G1/EEOtsm41p2dkD2qZkTMnKYkLMPD2L6utl2LgQQ5gEOEKIXnultjbq95k5OdiHQPamjdJJFmer389mv3/A2iSE6B0JcIQQvbIzEOCjmNFT++XkDFh7emp0RgYTYmpx3pcRVUIMWRLgCCF65dXaWoyI30c6nYwcAsXFnTk4I7rdG/1+tkoWR4ghSQIcIUSPmabJqxELVwLsn5s7YO3prdEOR4danA9jslNCiKFBAhwhRI+t9/nYFJHhsAEzhlBxcWfmFhRE/b62pYXaoCzhIMRQIwGOEKLHYueLmZSZSXbEIpZD0YSMDMpjuthi5/gRQgx+jgT2EUKITr2za1fU7301NPyF6uo+OW9nFEXh4Lw8Xo7oelva1MRRhYVk2OQzoRBDhfy3CiF6ZLPPF7U0gwLsk5U1oG1KlX2zs8mJCGYCpsnSxsYBbZMQIjkS4AgheuSdmO6pCRkZQ757qo1DUZiTlxe17dPGRpn4T4ghRAIcIUSPxNbfTB3ixcWx5uTmEhmu7QqF+DpmMVEhxOAlAY4QImnbAwFWNjdHbZuaJt1TbXLtdvaNCdq+iFlvSwgxeEmRsRAiaR/EzPC7f04OeY70ezmZnZvLlxGB3OrmZprD4ZR0xfnrwzRsD9FcGyYcNFGAjHwbOWUOckc6sNmHzlIXQgxG6feKJIToc7GT3x0ZM3dMuhifkcEIh4NdoRAABrC8qYlD8vN7dD4jbLLzKz87lvtoqAh1uZ8zW6FkWgaj52SSkZsedU1C9DfpohJCJCVoGHwSMy/M4T18wx/sFEVhdszMzF/0sNi44rMWXrq4gnVvNnYb3AAEm022f+5jyZO72fy/ZoyQFDcLkSwJcIQQSVna1ESz0b76VLHDkTbDwzuzX05O1AtldSjEtkAg4eNDAYOPH67lzWt3sHtjcjMiGyHY+nELy/9VR8uucFLHCjHcSReVECIpsd1Th+XnoyjpWy+Sa7czJSuL1S0te7YtaWxkbMyaVZ3x1YV5+zc7qVrZ+YKdueUO8kY7cOXYMEImzTVhdm8MEg5EZ2yaqsIse7aOaafmUTDOmYJHJUT6kwBHCJGU2AAnXbunIs3OzY0KcL5qbuaEESO6ndm4oTLIm9fuoGFbx+6o0n0zGHtIFlmFHetrwiGTqpV+tnzUTLC5PdAJB0xWvljPPiflUjwlfnAlxHAnXVRCiIRVBQKsjXijt0GPC26HksmZmeRFjJwKmiYruhkyblQbvHF1x+Amd6SdmefkM+XE3E6DGwC7Q6F8v0wOOK+Q4inRa2KZYVjzeiO7vk68i0yI4UoCHCFEwv4XU1w8IyeHwjQcHh7Lpijsn5MTtW1ZFwGOUW/SdFsLjZXRwc2oAzI57dHR5I9JrIvJkWljHy2XCXOj5+IxDVj9agP1FbLCuRDdSf9XJiHEHr1dtPLFmOML7fZ+XQhzIO2fm8v7Ed1z2wIBqoNBSpztAYsZMGm+twWjMrqGZtLR2Rx5bSl2Z3K1SoqiMObALJxZCuu87QGVEYYvX64n4wwXttzU1T9NJS+BvYQYGiSDI4RIiGmabPJHF8tOSuPRU7EKHQ4mxBQWR2ZxTNOk5VE/4bVG1D4T52Uz7/rkg5tIZTMymXxMdAYJHwS8QUwZQi5EpyTAEUIkZFcoRGO4faiyQ1EY7XJ1e0y62S+mm2p5UxOGNSdO4M0gwQ86dkvNu740JbMSl++fydhDogNKs8Yk+FH3c+oIMVz1exeVqumTgCeAo4BJXo97Yzf7ZgH3AucA+cAK4Bqvxz2/f1sthIjN3ozLyMCexsPDOzMtO5s3d+0iYAU1jeEwG3w+Jm514XsquvC3YLyTY27qXeYm1rhDs2iuClG7ob3+JrzKIDw2jH2izHgsRKR+zeComq4DHwGbEjzkYeB44BigBHgWeE3V9Cl93FQhRIxNMStpj09gHph047LZOizA+eWuJloe8kHkPHxZcNwtZSlfZkFRFPY+MRclPzpoCiwKYTZLV5UQkfq7i6oImAc8FW9HVdOLgB8A13o97pVej7vJ63H/AfgKuKR/miuEoIv6mwmZmQPWnoEU201V/AIdioqzL82kYGzfTMjnyLDhOsYR/erth8AHoR4tISFEuurXLiqvx/04rcHLuAR2n2O175OY7YuBQ+MdXFtViRE24u02JIRCQaorKwa6GYOaXKP4QqEgjU3NCezZ0a5wOLr+BshvaabR19LtcUNN2AjTWLe7231GmCYFNoU6w2T0egf7vR8d6ClHGfinNnb5fGys7/2SC4HcAOynwBftUY6xycC3ugVlQs/Pm8j/kPyvxSfXKL5UXqOS8tGdbh/Mw8TLrO81MdurgfJ4BxeVxt1lyKiurOjyDyhayTWKr7qygtzMnAT27GhtYyPQPmJoXGYmBYUjUti6waGxbje5BYVx95ut2PhwZx3HPR99PZUyhbwf5qFkKpSUlHR6bE1+Q6fbk5HZ2Ig5x8S/LYhZFZG1+cxOxmQXiqtndT8l5aPi7iP/a/HJNYqvP67RUBxFpQCShxWiH0n9TbRZOTkc9no2BbXRNTbZl2SiZPZP4bViU3DNi+mqaoHQF7IopxAM8gCn0vpeGrO9LOI2IUQ/2CL1N1FyvlbY78Poa7DjmDCO6f07ksk2woZjVvR9hr4MY9TJZ0AhBnOA8xkQAA6L2X448MEAtUmIYac+FKI+ov7GDowaZvPfRDINE98T0QHf7uIwbx3fQHgAinwds+0QObDLgODHMjeOEIOqBkfV9DuB8V6P+/tej7tO1fTHgTtVTV9pDS2/CphgDR8XQvSDrTHZm1EuF45hNv9NpOC7IcIbogcwvHtWE3VOg/UtLewTM4y8rylOBefBDoIL2oMaY7NBeKuBfexg/gwrRN/q73lwVqua7gM81qbVqqb7VE3/m/X7KCuAafNL4FXgXaAKOAk4wetxJzqPjhCil7YFoiewGzuM62/MRhPfc9EB39r9/GzbuzW46GoBzr5m38uGrSw66Az+L4RpSFeVGL76e5j41Di3XxDzux+4wvoSQgyA2AzOmGEc4PieD2BGDIIyXfDBKe1D5de2tNAcDpNt799aHEVRcB7uwP9i+wzHZp1JeLWBY1+Z4VgMT5K/FEJ0KWgYVMZkcIZrgBPeFCbwVjBqW+YZTjJKIuaiAVY092yuod6yldiwT41+SQ8uCclinGLYkgBHCNGlykCAyGqTArudvH7OTgwWvmcCURNU2MoUMk5xdZjZeGljY/83zuKc42itAm/TDOGvZNi4GJ4kwBFCdGmr1N8AEFoeIrQsOlDIPC8DxaUwMyeHyOqXHcEgO2KuW39RcpQOQ9WDS8OYQcniiOFHAhwhRJek/sYaFv5sdMBin27H8Y3WQCLf4WBSzLxAA1VsDODY3w6Ry2D5ILRCsjhi+JEARwjRKdM02RYT4AzHDE7w447DwjO/50KJGCq/f0w31ZdNTQSNgVkLT8lUcMyMmfxvWRjTL1kcMbxIgCOE6FRdOExTxJu0U1EY6eybFbIHKzNk4v9XdPbGcYgdx97RAcQ+2dlkRgQ8zYbB+/X1/dbOWI6ZdoicizEAoeWSxRHDiwQ4QohOVXQywZ9tmE3wF5gfwqiMrCyGzG93zGI5FIXpMVmcV2pi1wnuP0qGgmO/mCzOijBmQLI4YviQAEcI0antMYWyw215BtNv4v9v9DVwHevAPrrzl83Y0VTv19VRGwx2um9/cMywQ2RpUBBCKyWLI4YPCXCEEJ2KDXBGD7MAJ/B2EDNy0coMyDir62sw2uWiJKILLwx4amv7upldUpxKa5ATIfRlWObFEcOGBDhCiA5M0xzWGRwzYOJ/JTr74jrBiW1E1y+ZiqJ0yOL8p7oaYwAW4GzjmN5xRFV4lWRxxPAgAY4QooOaUIhAxBtzps1GoWNQrc3bpwJvBzF3x2RvTo0f4M3KyYl6Ud3i97Oorq5vGpkAJaPjvDih5WHMsGRxRPqTAEcI0UFn2RtlmBQYmwET/8udZG/y4z/+XLudGTFZnGd27kx5G5PhmGGPmt3YbILwuoEZwi5Ef5IARwjRQWcjqIaLwDs9y960OTgvL+r3zxobWTVA61MBKNlKhzWqQkvDstK4SHsS4AghOhiu9TdmkB5nb9qUu1xMiJkQ8Z8DncWZ5SByPQmz3sTYJFkckd4kwBFCRAmbJjtihjcPlxFU5iIFc1dM9uaU5Cc3jM3ivFFb22HZi/5ky1Ow7x2TxZGJ/0SakwBHCBGlOhgkFFFgnGOzDYsVxM2Aiflm9EuiS3ViK0j+ZXJKVlZUFicM/G379pS0s6ccs6L/hsZOE2OnZHFE+pIARwgRZbgWGAfmB2F3xON09Sx7gzVk/MJRo6K2eWpr+drn620ze8xWZMM2JvrvKFkckc4kwBFCRKmMDXCGwQKbZtDE/1JM7Y3qxFbY85fIE0eMYHLEKuMG8NcBz+JED/UPbzQwGqTYWKQnCXCEEFFiA5zyYbDAZvC9UHTtjQsyTu3d47YrChfHZHHe2rWLDc4BzOKMUVBGRFYbt85uLEQ6kgBHCLGHYZrsjCkwLk/zAmPTMPG/ErPm1HG9y960ObawkKlZWVHbniyowmBgsiaKonSoxQmvCWP6JYsj0o8EOEKIPXaFQgQjCoyzhkGBcfDjmBXD7T2vvYllUxR+NmZM1LZ1Lh9vZw/c7Mb2vWwQGXMFIbRasjgi/UiAI4TYI7Z7aqTTmdYFxqbZsfbGeaQDW3HqXhoPy8/nmIKCqG3P5lez3R7o8pi+pNg7Lt8QXiET/4n0k/B/sarpBQnsJoQYwnbE1t+kefdUaGkYY2PEUGnFJOO01D/mq8aNI8fW/nLrt5n8sWg7fmVghmk79u1k+YYNMmRcpJdkPqZUqpr+tKrpx/Zhe4QQAyh2gr+RaR7g+F+KyaIcYGIfnfrE9iiXiyvHjo3attkZ4KHCSsIDUI+jZCrY9+k48Z85gCufC5FqyfwnnwdkAq+qmr5B1fTfqJo+rg/bJoToR6ZpdhxBlcYBTmhNmPBX0VkL24l9l8U4vbiY4wsLo7Z9mtXEw4WVBOn/7IljZnQ3lVljUrl04EZ4CZFqCQc4Xo/7ea/HfTYwEvgdcDiwRtX011VNP1vVdEcCpxFCDFIN4TDNRvsbrUNRKHKk7791bPbGMcuOMrHv7k9RFH47YQJjg9FB4/+yG7mtZBs7+rkmx1ZgwzYh+i1gpbuhX9sgRF9KOhfr9bgbvB733wENuBA4BPg3sEnV9Iv7pplCiL4W2z1V5nRiS9MC4/CWMKHPokcOZZze9/P95NjtXFszmpJQdOC41uXjV2WbeTJ/J+ucvn4bRh6bxdn8YTMNFcEu9xdiKEn645mq6dOAHwM/AHKB54G/AaOBP6iaPsnrcV/XN80VQvSV4VRgHLtiuH0vG/YZdqjv+/suNpzcWDOWu4q3Uelob0dIMXkrt463cuvINmzsFchkTMjFmJCL0SEXY0JO8o3UZtRs5QpKsYJZYwVUJqx8sZ5Dflqc0vsRYiAk/N+iavqPrMDmUGAZcCvwtNfjro/YZyXwESABjhBDTIch4mka4BhVBsEPQlHbMk7v3/W2ysJObq4ex6OFlSzJbO5we7PNYHlmM8uJvi03bGN6IJuxppPJTRko9K7NiqLgmGknuLD9eqx9o5EDzh+BK0dmERFDWzIfB/4IPAdc4fW4P+lsB6/H/ZWq6Yu6OoGq6VnAvcA5QD6wArjG63HP72L/acA9Vr2PE1gF3OL1uF9Lot1CiARUxY6gStMlGvyeIJE1vbbRCo4D+38yw3zDztW1o1mU1cC/82uotYfiHtNoN1ic1cjiMVDmc3DCzgJG+XoXiNon2wguBlpafw82m6x9o4EZZ8nMIGJoSyZEv9vrcV8UG9yomp6navrtbb97Pe5TujnHw8DxwDFACfAs8Jqq6VNid1Q1XQHeBBqAvaz9nwFetAIfIUSKBA2D2lD0G2xpGgY4ZqPZump4hIxTXSi2gak1UlCY15LP/TsmcNmukRzckktuOLGX5Z2ZIZ4ZV8MnhY2YvajZUexK67w4EVa6GzDCMmRcDG0JZXBUTbcDN1iBTOwrwUTg58Cv45yjyKrbOdvrca+0Nv9B1fTvA5cAV8UcUgaMB/7p9bjrrHM8bmWS9reyOUKIFKiJCW4K7XZctqHZRRF4u+si2eDSEPgjNmSDGTD3HGO0KASyUlNkuzo38RFJTmwc0ZLPES35GJhUOAJsdQSocATY5ghQ4QxQ4QgSVKKDDlOBBWUNNDsM5lXn9bjLyrGvndAX4T2ZrcbKEFs+ambCETk9Op8Qg0HcAEfV9BuA21rLz+gqh/pFAvc1x7q/2O6txVZdTxSvx71D1fSFwI9UTf/YyuRcDNQACxK4PyFEgmK7p0rTsP7GDJuEVkSPnHLMsKPYB9dIMRsKY0MZjA1lRG03MFnn9OHJ3c3irMao2xYXNZEdtnHQrtwe3aeSpWDf20Z4TXvf3cr/1kuAI4a0uAGO1+O+Q9X0V4DPgIs62aUJeDuB+yqzvtfEbK8Gyrs45lvA60CVFWBVWxmgHfHurLaqEiOcHlOPh0JBqisrBroZg5pco/hCoSCNTR0LWgG2tURP8FZghGms291PLUsto6XzgMVcr0BzRFbKYRKaECDc0l5cbZoGvpbOr1GyGo34NTXJGg1cWJNFWYbBm+ObCUb0LC0oaWBEncHYpp6NtDL3Bta0n7BymZ/1H22lYGLMjMfyvxaXXKP4UnmNSspHd7o9of8Er8e9XNX007we9xspaU00xQpeoqia7rJqcFYBJwONwPnAK6qmH+b1uL/s7qRFpV3FTENPdWVFl39A0UquUXzVlRXkZnb+iXy3f2fU72Ny88jNGZqf3jvrYjJNE/+qYFStin2qA1dh9Eugr6WZzKzslLQjN7dn2ZRE7NvooGhrNs+NrSFgtx6TAt4JLfxwUymZRg+6F7OgYLZC5RftwW7FexnsdWhp1G7yvxafXKP4+uMadRvgqJr+G6/Hfav16+Gqph/e1b5ej/u3ce6r0vpeCmyN2F4WcVuk44HZwMlej7vt1fcvqqZfCvwIuDLO/QkhEtShiyrNCoyNrQbm7ojPUUrHSe6GmpF+J6dtH8F/xtTuqYxsdBosKmlA3dmzEVAzzsyPCnA2vNvENy4cQXZR+s5oLdJXvDD/+xE/n9vN1w8SuK/PgABwWMz2w4EPujkuNt/s6CzjI4ToGb9hUB9ur01RgOI0C3BCy6Nrb+yTbNjyBlftTU9Mas7g4F3RmbYvCprZkdGzQumxh2SRN7o9mDGCsPoVWb5BDE3dhuVej3taxM+TenNHXo+7zhoFdac1IeAma+TUBGv4OKqm3wmM93rc3wc+tDI7d6mafoVV6/MDYKpVbCyESIHY7E2xw4EjjZZoMKoNjIroz0SOWUM7exPpiJo81uT62O2ygjgFFpU0cPa2oqTPZbMrTNfz+fih2j3bVr3SwKzvFuBwDc1RdWL4SuoZq2r6CRE/769q+n2qpl+SxCl+CbwKvGsVDp8EnOD1uDdZt4+yAh68Hvdu4ESgGFhj7X8pcI7X4+5yMkEhRHLSfQRVbPbGNkrBVpo+b9YOU+HYqvyobV/n+NmW2bPFO6ecmIszuz3A9e02+Hp+U6/bKUR/S2aphuuBnwGjVU0vBeYDS4BTVU0v83rct8Q7h9fj9gNXWF+d3X5BzO/LgO4mDhRC9FJVzBIN6VR/YzSYhDdEj6Z07Jc+2Zs2k5syGNPsZFt2e7D6UVEjZ1Ukn8VxZtvYR8tjxX/aF+Za8UI9e5+Y26/LWQjRW8l8jLkwItj4HrDe63Efb2Vhzuuj9gkh+lg6FxiHVoSjKvaUQgXb2PTJ3rRRUJhbkxe1bUOun1pnz4aq73t6HkrEZdq1IUjlUl93hwgx6CTznz7S63F/bv18IvACrVmW9d3MYyOEGOTSNcAx/SbhVTET+82yp20WYlyLi3Jf9N/usxE961rKG+Vk/OHRw+VX/LcflloXIoWSCXDqVE0vVTU9HzgSeIvWrqtSIDUzYwkh+lVTOEyT0d6FYwdGONJjSHBoVTh67vUssO+dftmbNgoK34gZUbUyr4WA0rMJT6efFV3Xs+WjFuq3pWYZCyH6QzL/7S8BXmuZhLVej/tzVdMzrbWhFvZhG4UQfSQ2e1PidGJLgwzHUFmWIdWmNmSSE2p/WQ/YTdbk9axraeTMDIqnRBScm7DyRcniiKEjmQDnl8BzVjBzasTxpdZim0KIISZdu6fC643ovLKDDitmpyM7CjPqs6K2LcvvWYJdURSmnxmdxVn7RiPBZpmGTAwNCeeirRFQd8VsawbUPmmZEKLPpeMQcdM0O07sN9WOkpHe2Zs2s+qyWVzUXnuzLTtInSNEQSj5rsdJR+Xw6d920VLbej1DLSabFxiMmpzSJgvRJ5IZJp5hLZEwA+iwWIvX4/5RylsnhOhT6ThE3NhqYO5Kr2UZklEUdDC6xUlFxJpcq/J8HNKDlcbtLoVpp+Wx5Mn2hVe/fivMQeeb2NK8u08Mfcl0UT0J3AccCkyJ+dq7D9sohOgDpml2yOCUpUGAk67LMiRj34bobqqv8lt6fK6p38zDHvG0aKmGzR/KuBIx+CWTszwZONDrca/ow/YIIfpJQziM32zPdLgUhXz70M50hDeF03pZhkRNbchkfmk9phXXVWWEqHWGKAom302VNcLO5ONzWft6455tK1+oZ+KRQ3O1eTF8JJPB8QGr+7AtQoh+1FmB8VCfI8b/WvRjspWn17IMicoJ2xnXHF1PtT635xP1Tdeji413LPdTvcbf4/MJ0R+S+c//G3BBAvsJIYaAdBtBZewyCH4QPXPvcMzetNm7KTPq9/U5PQ9Iiia7GHVA9PlWviBDxsXglky+0gXcpmr6hcA6IGr2KK/HLcs1CDGEpFuAE3grCBHlN0o+2MYNv+xNm72aMpgf8fvWrAA+m0Gm0bNrMuOsfLYvac8Cfb2giQMvHEF2SXpMDCnSTzLPzCOAr6yfx/RRe4QY9J76uGerNA+Ecw/petj3zjQaIm4GTAJvRz8exwwHim1od7n1RmHQQbHfQU1Ga1bLVFpXGY8tQE7U2IOzyBvjoGFb6/mMEKxw13PQRckv6ClEf0hmHpy5fdsUIUR/MUyT6jTK4ATfC2E2RGxwgX2f4Zu9abNXU8aeAAdgfY6vxwGOYlOYcWY+Hz1Yu2fb6lca2O+7BWTkDt+uQDF4JfUKoGp6nqrpF6iaflPEtnF90jIhRJ/ZHQoRihhBlW2zkWMbmgGBaZr4X4/Oqjmm2VGcwzd702avxui6mQ05fgx6PhPxlBNzcUXUGwebTVa/0tDdIUIMmIRf0VRN3w/YANwD3GBtmwSsVjV9Xp+2UgiRUuk0giq0NIyxLXpiP/t0ySgAjPY5yYpYm8pvN9mW1fMuVkemjUknRl/blS/UE/L3bEFPIfpSMh/Z7gX+CoxsKzD2etxfA1cCd/ZdE4UQqdbZIptDVSBmaLh9kg1b7tAM1lLNhsLkpoyobRuzeze8e+LxNhxZ7de3ZZfBurcauz1GiIGQTIAzB7jN63GbrevK7vE4MLMP2iaE6CPpMoIqvCXcYebi4bQsQyImNkcHOJuye1ck78pRmHZKXtS2L/9djxGWRTjF4JLMKCpnFwFRcUzAI4TogWDYpMEHzUGT5gA0B0z8wZidFHDawWWHDIeCyxH9c4YDHDbidjelyxINsRP72afasJUNzVqivjI+ZsK/yswgfptBRg+Hi2MNGV/5Yj2GdfkbtofY+F4Tk49Jfr0rIfpKMgHOu8Ddqqb/sm2DVYPzsHWbECJBLUGTDdUGW3aZbN1lsLPBZHfPlwuKYlPYE+z83hsgw9kaBNnJJpBl4nAaNH8jCBEx0DsfunDZwG43cdhbv9vt4Njzvf02mw36qlzn0MmJvyQZuztO7JfxTRdmvXzeipQbtncYLr41K8BeMRMBJiO7xMFeMcs3LH+unklH5wzZWi6RfpIJcH4JvAI0Ak5V03cDecBK4NQ+bKMQaaHBZ7Jka5gVFQabak2MPnofNkzwBVu/opOrrV03jnw/ZRHvQeFmB598nvjQYZvNJDPDJCvDJDPTJCvTJDfHJD/HIC/XJC/XwNkPc78FvEGISOAoZQqOA+0E54e6O2xYGt/iihouvrmXAQ7ArG8VsPaNxj1Psdr1ASo+9THmoJ4NQxci1ZKZB2ejqun7Az8AxgN1wBrA6/W4pYReiE6Ypsm6KpP314dZVdmbAbqp4yiIrsEI1iU3wZ9hKDS3KDR3k3HKyTYoGWFQPMKgeESY4kKDVPaCmQGTgDcme3OSc1hP7Ned8c0ulhS2rwC+uZeFxgAF45xMmJvNpkXt5132XJ0EOGLQSCjAUTU9H7gL+A5QYG3eZhUYz49dtkGI4c40TVbtMHhzZZiKusTCGgXIy4Rsl0K2C3JcCpnOzYGJ2wAAIABJREFUqJ4kTCAYBn8IAiGTQBgCIfCHzNbvYQjH+W90xgQ4ofrUz2Dc1GyjqdnGpm3WY1NMSooMRpeFGTUyTPEIg97EIsH3Q9FdUVngOnpo1hH1h3HNGa1PHuua78wM0WIzyOpFHQ7ArG8XRAU4lUt97Fzpo2x677JDQqRC3ABH1fQMYAFQaA0HXwFkAgcCPwWOUzX9WK/HLXlhIYCKOoOXl4XYUN19YFOWp7B3qcK4ETbGFCoU5yg47b3PQIQMK9ixAp/WYAjqGprY5jLZXtpC5LrSJRl2yiYGCYcVwmEIhSEcVqK/hyBkKIRDYJjJt9E0Fapq7FTV2Fn6FbhcJmPLQ0waF6a8NEwycwyaponfE11c7DrWiZIt2ZuuZBk2yvwOdmZGdFNl+5na2LtsS+m0DEYdkBm1RtUXT9Vxwp0S4IiBl0gG53Kr83621+OOXD72BVXT7wfeA64Aft+H7RRi0AuGTd5eFWbh2nCX9TWj8hXmjLcxa7Sdopy+eUN22BQcLsh2QWT+pzHTIKMgTKU9OoMza6xC/tjEhw4HQ+DzKbT4FXw+haYWhYZGGw1Nrd8bmxXMOEFQIKCwYbOTDZudZLhMJowJMWlcCHNS/ALm0LIwxtaINJXS2j012CxpHFxzw4xvzogJcAK9DnAA9vteQVSAs+2TFsniiEEhkQDnLODamOAGWutyqqxRVXdKgCOGs+11Bv/8JMSOho6RjQLMGGVj3hQ7E4sHdghzGIOWyCW3TchJaqwBOB3gzDXJy+08iguFYVedjZpdrV/VtXbqG7t+3P6Awpqvnaz52smyFQZz9w9zyAyDrIzO9w/EZG+chziwlcrQ8HgmtLj4lKY9v2/txYzGkUbNzmTkrAx2LG+v61ny992ceHd5Ss4vRE8l8sq2L7Cwm9vfBfZKYZuEGFI+3hjmpaUhQp3UvuxTpqDNcDC6cHC8ATcRiirqycKOPbkl6eJy2KG0yKC0qP2CNDUrVOy0s32Hne077QSCnadpttfYeH6+jZfeMzlwX4Oj54QZU9oeSIW3GoSWRk/s59IGX/ZmMBrT4oqqw6nOCOGzGWT2sg5HURQOOL+QN67esWdbxWc+dnzpY+RMyeKIgZPIMzvD63F3OV7C63H7kxxuLkRaCBsmLy4N8t8lHYObgkw4/xAHFx7hGjTBDUCTEl0ql2P2T3CQk20yZWKIeYf4OeebzRw/t4W9JwRxOTvPAgVCCh8ut3PH31089B8nqzcrmCb4PdFZB/sUG459ZObiRGQYNkoC0S/VFSnL4mRRvl90ym3J33en5NxC9JQEJkL0gC9o8vTiIGt2dnyD/sZ4G6fv5yBzEK5m3ahEd+/kDsBLgM0Go8oMRpUFOPiAABU77GzY5GDLdnuntTsrN9pYudHFlMIQ578XivpUJtmb5IxpcVEdMR/OtswAk3s5H06bA84fwetXVe75ffsSH5XLfZTPkiyOGBiJvLq5VE3/R5x9EnqVUTU9y1q08xwg3xqRdY3X457fzTE/Aq4FJgAVwINej/v+RO5PiL7Q5Df5v/8F2bIrOrhx2uGs2Q7mjB+8GYUmBiaD0xW7DcaNCjNuVJjmFgV/vYv3l9nZ3dAx0Bm7MoAtovlKiYLzYPmMlowxLU6WFrb/vi0rdi2QnivfP7PDiKrPn9jFyX8ol9mNxYBIJHf+PjAuztf7Cd7fw8DxwDFACfAs8Jqq6VM621nV9G8DvwXOs+bf+RlwiarpByX3MIVIjZ0NBo8s6hjcFGbBZUc5B3VwQ2cZHHPwBAjZWSYnHxbmlosCXHR6kEmj2/v97IbJoTt9UfsvKs5kyTp7n80InY7GtETPebQ9M0A4hdNPHnBeYdTvO5b52fpxitYgESJJcV/dvB730am4I1XTi6xZkM/2etwrrc1/UDX9+8AlwFWdHHYT8Cuvx/2x9ftr1pcQ/a6myeBbj7V0GCk1tlDhh4c5ycsc3J9S/YqBX2kPGhQTsgdhL7XdBrOnGMyeYrB+m8Lbn9ixfRwkL9R+3f02eCcrE/8rNkYVG5x8WJgDpvZu8sDhoCBkJydko8nR+jwI2WBnZpBRvtRM9jhyViZjDspi2yftQc2nf9vFmIOysKVgjichktGfr27/3955x0lS1vn/XVWduyfH3dmcM7DEXZIIA8sgYRBUBBXPhD9/d6YznN7p6Z1y/LzD80459UBUjCgO4DIiA6xIWmCXBTbnPDn1TOfuquf3x/QyXT1hZ2Y7Tffzfr32NTvVVdPVVU8/z6e+cW38/V5L2v4qcFHyzvUNjTPiGVxafUPjFmApcAj4Vktz08OZO22JBPoDgvfdH2RvhzmaeGGlwocusuZkvE0yfZrZeuPCgkpun/fCOsGCmVH6XzJbAbZWOghbhgzQbT0qP9moMnOzwXUX6ywX6WsGOt1RUKgL2thXlFC3xhFJmcABOO9jZZzcEny7R1X/0SgH/uxjSUNRyt5DIpkImRQ41fGfPUnbu4HRCibMif+8C7gtHn/zUeC39Q2NHS3NTeOlrtPb1Y5xupr104RYLEp3e2u2TyOnSec1Csfg401OdrSZvy6LKnTesypKLBjENw2s8L1Wc/8hZ0whHM6tE/d59RHbxCFQj5mv/eaakUVyWrtV/vcxlZl2uKrSzzJ3ZNJCRwiDUDAwgT2nLzUDsC9BaxyzBVkVHBKLE/kOnfa75oLZl6gcf354/t3ykx6KVwxgyXErZ6qQc/bpSeU1qqydOer2XLBPK0ktj09x6ty+0dLctD/+/+/FXVofPk1tHsqr8qfIVHd765g3UDJEuq6RYQg+8esQr580B+curlK4c50Tq+ZK+Xumi/5Yn+n3YtWB3ZFbjRE9JSOnpMDzIYyE4GjLORqf/KjBk5t1tuxRR2RetYat/PxkKXNdOhtqIywt0icsdELBAA7n9LmnU2FuzMLzCc062j0GdqcTBYXK2hmnPX4i37WLPhmj9ZWT6JGhqT3cD+0vuDn7jtJxj8sX5Jx9ejJxjTIpcE7lD1YBJxK2Vye8lkh3/Gdf0vZDwOm/hRJJCviXP4XZuN0sbuZVDLmlUtE3KpP0WcwuqslWMM4GRq9B9BXz9bdtsFJbIbjzuhjXrlNofllj624VkeRuOxrQ+NEhJwvcOtfWRlhUNNI6VIhUh61YjKH4GwC/xWDQYlAcS12AvKfawoqbi9n+G+/b27b/1suSaz24KqY+7vZuHEzRGaaepe+SLrhcI5MVyLYCEWBd0vb1wIuj7H8gLnIuTNq+CDicxvOUSAB4eGuUHz5vFgVLqlXuvMiKzTK9xA2jxOB4spwiPhEiT0dJ7CyhzlSwrB5eiGvKBR++LsZX7oxyzpLRBcwhv8YPDjq574CDw/7cKbqYLTQUakLme9/mSE3Bv0TWvK8Ee/Hw9Y4FBa/9OPl5VSJJHxn7trc0N3mBB4C76xsaV9Y3NHrqGxq/Hq9vcx9DgcV31zc0/jK+vw7cC3y9vqHxgvqGRkd9Q+PfAucAP8rUeUsKk63HdL7wB3Nack2Rwi//xonLNv3ETYChsvynUMVQm4ZcRkQFkWeSrDdXW1FGSZWaWSn46A0xvvzBCKuKYyNeB9jvs/Bf+1386KCDY4HCFjrJQcVtjtTVwzmFzaNy9gfMLqlDz/hpeyO34r4k+Uumv+WfBTbG+1d1ARuAq1uam47GX58RFzyn+DfgB8Dv48HJdwLXtzQ3bcvweUsKiG6fwUd/ESSSYBBwWOBnH3IyK4faLkyGHsUs1txYUXI8gyr6cgzhTQjPc4Lt8vGtTrOrBR9ZEOKzSwIsLxpd6OwZtPDdfS7uP+TgSIFadGYkWXDa0yBwAJbdUET5QvN7vfxfvehRWbxIkn4y6oSP9636TPzfaK/fmfS7AL4V/yeRpB3DEHz6dyHaB8wT8L23ODhrVm5bPMajWzFnULlzqMBfIpsPxUWJEMx7LEJiCHTvORq7204fR1ParQM6V5VEWenQ2Dzg4ER45OfdOWBh54CFOnuM84rCzLbH0GMqFv/EYnUWVE7f8VA7isAxUljw7xSqprDu0xU88XfDYZbeY1F2/WGA1e8tSfn7SSSJFObji0QyBj98Psqze80L3Kcut9F4du7Hq4xHsgUn1+NvnMcFzpPDC65QoHfd5AXFDLtOY5Wfm6t8zLSNbtE5GbbwWLeb33Z6OBiyFURl5JKYhjM2PP1HVUHPGNfnTKle4WDxBo9p2xsP9ePrTM/7SSSnkAJHIomz9ZjO3X82WzrOn6vx5atTVwQtW/SQ7KLKTQvOKcpeMi9+viUq0YqpT1d1dp2bq/zcWOmjdoyFvCuq8ZS3mF90eNjusxHJjzJao6KgZMxNRbz4n70oIeA4JHjpuz0IUQBqUpI1pMCRSOKViu/6VZBYwqJW6oT7bnNgmWbp4MkIBD1JLqpctuBYvILiHWZ10bf+zN1BigJzHDq3VPm5qdLHLPvoQscb0/hLv5MH24p5vt+BNza97/9YJLup0hFofApHica5HykzbTv5WpC9T/jS9p4SiRQ4koJHCMHnHwlxot/8NPmft07foOJEBokSSehBpQkFew5/9ctejZFwuoSrFPyLUne+igKzHUOuq/dU+1jojI5aazQiFN7w2fl5exEbu10cD2nkk8FhpAUn9aniiSxp8FCz2lyB+rUf9jJwMn3CSlLY5O4sJ5FkiN9sidG80/w0/9GLrVyzIrfdOBNlhPUGS85mUClRQemr5hiovnVa2ppL1dh0GioC3F7jY4UrgjpqoK3C4ZCVR7s9/KrDwxuDNoJ6bl6/yVCblCreZY8RMtLnl1NUhUu/UInFOXztYiHBX+/pxtDzSDlKcgYpcCQFTavX4OsbzfEpa+pU/vHakb2OpisjUsRz2D1VvN3A4h/+XbdD/znpz1YqtxpcWR7k9so+zi8K4VRHX+h7YxrPe538pK2Inx+xs39Qm7ZByS5DpSQyfG0NBfYF0tuHq2imlQs/WW7a1rUrzI7fesc8RiKZKlLgSAoWIQR//0iIwQQDh8MK/3ObE/s0rFQ8FiPjb3LUMiUEZS+bLWn952kIe+buhUczuKgkzJ0zBrmqLECVdfSUcQOFbf1W7jvo5O7dLp7usOKNTr8xk+ym2pFmgQOw+FoPsy8y90B7/Wf9dGwPjXmMRDIVpMCRFCy/3Rpj0z7zAvbVDXYWVObX16J7lCJ/uYjz2MjU8L6LslNrxqLAcneU91b7eHeVj0XOKMoYdWK6IypPtNn55k4XPznsYKdXY7p4XJIFzk6/f8x9U4WiKKz/XIWpjYPQYdO/dhHolanjktSRXzO5RDJBWr0GX/ujeeG/cJ7G36zLzcV/qhgIepkeFpwRqeFLzyw1PBUoCsy061xbEeDDMwZZVxyiRBvbqrPda+H+w06+udPFxlYbXeHctuokx+HszIAFB8BVbuGSv680bQv26Gz6RhexfM7Pl2QUKXAkBYcQgi/8YaRr6ru3OFBH6XM0nfESQVeGzQlWoWLLwR5UFq+geGdSavgUCvulE7cmOK84zAdqfTRW+lhbGkVTRjfVDMRUnum08e3dbv57v5NXeyyEc7CZeU3YSuJHOB4O441lxooyZ72L1e8zVzPu3BnmpXtlfRxJasjNRzmJJI08vDU2olrxV66xMz/PXFOMWsH4zL/ypa+mfgH07NJNqeHRIrD2GpS+mnsLnaLALIfOZZVhbo6F2dJnZXOPhfbQ6ILskF/jkF/jDycF55TGuLAiylyXka7EsElhFQpVYQudjuF7+udN3ZwVdo95jG9Ap6d4MCXv76nWKJljxXtsOFX84NN+Ql6DuRe7UvIeksJFChxJQdHjN/hG80jX1EfW55dr6hQjelDlYvyNLnAdMQuZwAI1banhqcRtgcurolxWGeVoQOWVHivb+i2EjZHnHjYUNvda2dxrpcZucGFFlPPKYhRZsyviakM2k8A5aA2NK3BSiaIqLG3wsP23XoJ9wwr35GtBLHaFuvOc4x4vkYyHFDiSguJfm8P0JYQZOCxDjTTzzTV1inRYcFKN84RAS6gxZ1ggOHt63Q9FgXlug3nuMDfVhXmz38LmXiuH/aNbdTrCKo+32tnYamNlic6F5VGWFetko2j2jJCVtxJ+P2QLj7N36rE4VJbdWMz233iJhYbF3tEXAqBA3blS5EimRu7NdhJJmth8OMZvtprdK5+90pZ3WVOJJKeI51wNHCFwHzLH3gTmKohpkKZ/qHvsoJpKdN5VFqbPo7IrYGWP30bAGDnOTgUmb/dacKkGK9wRVrkjFFlSb9UZq/t5csuGQ9bMp2s7SzVWNBaz4/dejITCxkefD6BHBLMvcqJMA4ueJLfI35ldIkkgEhN8+VHzYr+4WuWuS6d/I82xiGHQn5xBlWPPNNZesCbUeBOn3FN5QpnV4OKSMB+eMci7KvwscETHqJYMAUNly6CDn7UX0dzj4mQ4M60hKiIWLAkas1/T6VUzn67tqbGw/IZi1CQdduKVIAdb/LLasWTS5NZsJ5GkiR+/EGFvh9lScM9NdmzTwFIwVfqIkBgK4tY1LDn2TJNsvQnXKuju/LsnqgLznTHmO2MEdIU9ASu7/Db6YiOtKgKFg0ErB4NWKqw6a9xhlrqiWNN06zQUqsNWWp0Jgb62EOUhT3recBxKZltZflMxux8bwEjQWJ27wgR6dZZe58FelFvZdZLcJbdmO4kkDRzvNfiPZ8yNBN97roV1C/Jb3yfH35TpueWeUoMCR6v5qdy/MP/ETTIuTbC2KMLtNT5uqfKxwh3BOka6eU9UY1O/iwfbinjZayeQph5YyW6qw1lwU52iZLaVFTcXY3GYP6uvPcabv/TSvT+zMUKS6YsUOJK856uPhwgl+PXLXORVr6mx6EoSOOU5JnDchw1TDZZoEUQq81/gnEJRYIZd58qyIH8zY4B3lAYpt4we1xMWQ+6rn7YV8Zc+B95Yaq9TssA5aM2uiCieaWX1e0uwl5iXqFhIsO8JH3s2DhLy5mBhIUlOkd+PsJKC59m9MVr2mCfCf7zWTqUn/7V9sgWnPGYlZ7LEp3FqeDqwqbDaMxRgfDKs8abPzuGQBZHU9V1HYbvfzg6/jSWuKOcXhSmznnnl3+SKxodtIQQiq13nnWUaa24rYf+TPvqPRE2v9R6I0Hc4wsxzHMy6wIVmK8xxIxkfKXAkWeehVyIT2Gt8fANWPEfNf0c3BN991jwxzi1XiOoiJe+Z6yT3oCrXreRKz2bnCYE6zVPD08GpIoKzHAEGYgo7/DZ2+m2EkjKwBAp7Azb2BawsdUU5vzhMqWXqQqc8qmHTFSLakOj0qQadWoyaLFv9rA6V5TcWcXJLiOMvBxAJH1HocHJLiI4dYWrPclB7lgObK/8fXCQTR44GSd7yyhGDzsFhK4EC3LjGgloAVoIQMXzKcJSmKqAkV1xUo6WGz5seqeGZpNgiWF8S5s7aQS4tCVKkjRQwAoU9ARu/aPfwTK8T3xRjdBQUasLZTxcfDUVRmHW+kzW3leCpGRlgHAsJTrwS5PUH+jj4tA9/l2zYKRlCChxJXhKICJ7aZZ7ozp2jMqusMIZ8cgXjcuxoWXQ3JDJqavj8wrgvU8GqwtlFET5QO0h9WWDUOB2Bwq6AjYfai9jstTOVfpUj6uHYckPgnMJdZWH1+0pYdLUH6yiZdoYOHTvCvPlLL9t/66VzVxg9JlPLCxnpopLkJU/v0QkkeKdsGmxYWTjDPdk9VSkcWTuXZNwHCyM1PNVoCixzR1nqinIgaOWVAfuINPOYUHht0MFOv42LSkIsd0WZaJHukQX/ci9bSVEUqlfYqVhk4+TWIG1vhNDDI0XMYFuMwTYfR55TqFphp2a1A1e5TC8vNApnxpcUDJ2DBi8dMj/lvnOpRrGjcBbRZIFTkSMCRw0IHG2FlxqeShQFFruiLHQOC53+JKETMFSe7XOxwxfjirIg1bbTm3RGSxU3EKg5YvlLRLMpzFnnou5cJx07QrRuCxEZHPkZY2FB27YQbdtCFNdZqF3joHyhDVW6QwsCKXAkecfG7TpGwhpa5oJLFxXW01s3o1lwzjzb5kxxHyns1PBUoiqwxBVlkTPKLr+NzQN2gknByJ1RCw93eljjiTCzLIpjnK9BSUzDo6v44rE+IVXQZolSF8vdat+aTWHmWie1ZznoPRihY3sY7/HoqPsOnIwxcNKHxTlkBZpxjgO7p7DmhUJDChxJXrG3w2BPUsXihpUWrNnoYpglBGJED6ohgRMY85iMMEpquH9h4aaGpwpVgVWeCEtcEbYO2tk2aEdPsLoIFN702Tmyx8rNdWHWlI5eP0ZBYUHUwVva8Dg5aA3ltMA5haopVC6xU7nETrBPp2NHiM6dYVPzzlPEgoLWrSHa3wgxY62TuvMcWOwyBiwfkQJHkjfohmDjdnNg8bxyhTV1hTV5eYkQVYZFnl1oeLDgz+pZjZIaboXQLCluUoVNhXUlYVa5I7zgdXAgaBYm3qjKg0ecLHNFuKw0yGhrut1pg9nDAuelYBDbYZdpn3BIw96T/kyli+ZPbXlylmnMu9TNnHUueg5E6NgeYuDkyPM1dDj5WpCO7SFmXzhkBVImGrAkmRZIgSPJG145YtAxaH5iu36NpeC6ECdnUFUKe1YLtkE8Nfzg9OwaPt0osgiurQhyJBjluX4nA7pZyewJ2DgRtnBVWYDZDrM1p8ZnFkWdntwLNJ4oqkWhapmdqmV2Aj0xOraH6dwdHhGUHAsJDj8XoGtPhEVXu3FVyGUxXyisR1tJ3hKMwlO7R6aFzy6QtPBEcjGDytYD1oHh32VqePqZ54zx/ppBzisKjehg7tNVHu328Hy/g8Qm3dU+cwuTLncEfYw+WdMJV4WF+e9wc95Hy1jwTjdW10hh7euI8davvLS/FUJkoo27JO3IGUaSF/z1sIVAgvvDpsGGFYX5JJbcoiEXBI4ruWv4DJkangmscbfVe6p9VIxSP+cNn51HOt0MxntbeSIW3OHhwFtdE/S48qfqt2ZVqF3jYO2Hy5i9zomaVPvS0OHQs372/9mHIWvoTHsyugLUNzQ6ge8AtwLFwE7giy3NTc9O4NiLgb8C/9LS3PTPmTljyXSga9DgtRPmbIgrlmqUOAtzAR1hwSG7AmfU1PAFhXlvskWVzeA9NT42ex1s89nidb2H6Iha+E2nh2vKg9TZocZn55B9OA6n0xOm2p9fzWk1q8LsC13UrHJwaJOf3gNmEde9J0Kof4BlNxTJ9g/TmEzfufuAq4ArgErg18AT9Q2Ni8c7KC6MHgR8mTtVyXRh4w4dQwxP2KVOuKzA0sJPEcWgD/NkXSGyuziN6BpeLFPDs4FFgUtKQ9xc5ac4qe1DyFB5rNvF0wMKVUlxOB2e/LHgJGNzqyx7VxGLN3hGWHN87TF2/M5LeEB2LZ+uZEzg1Dc0lgN3AF9qaW7a1dLc5G9pbvoPYDdw12kO/zawB9iWodOVTBP2dRrsbk9KC19VWGnhifQq4cSHc0qEDRvZE3tKbJTU8ALuGp4L1Nl13lszyDxHcr0YhacHNXa0Ok1bO6ZxoPFEqVpm56z3l+JMitkL9Rlsf3iAkFeKnOlIJl1Ua+Pv91rS9leBi8Y6qL6h8RLgA8DquMVnQvR2tWPo2S9slgpisSjd7a3ZPo204RuYWhNIw4DH37CZdPqsEoOFRT58A+MemrecsPvAM/x7aVTDNzjU+MnQdcKh4Bm/R2z0Omqj4j4KanRYzOhWga9WR0Rzc8EwhCAWncQHnKZYgA3FXl63OHnN50IkqOKDHU5qE/btdUXwRwJYjKF9DMNIyTg6Hb5MW040WNAARzeBL2G6jfgMtv+un4UNKjbP2MK8u33w7f/n+5ydClJ5jSprZ466PZMCpzr+sydpezeYvk9vU9/Q6Iq7pj7T0tzUVt/QOOE3K68a9U9OS7rbW8e8gfmA5+jUTOAvH9bp9JszpxrPsVNU4hzzmHzHp5qL+dVqHjzFJUOvDXixO8782lisE6yBIgRFR82LVHCeijZeOd0sE4tGsVhzpOt6BrjQFmOGw8+fe12E4lWQjYhGzGfB4hm6z4YKA+UqM3xDsVzhUDAl4+h0eIqzkySw6t2C/U/66Nk/PC9FfXDkKVj93mKsztEdH5W1RW//P9/n7FSQiWuUC9FTSjxrdDS+DexqaW76RYbPSZLjBEfrFj67MNPCE+nKoQwqW5fAOvxQi1DAL1PDc445Dp33VfuosA6L0Wivedx0FuW/m+oUqqaw5FoPVcvNsUihfoPdjw2iR2V21XQhk7NNe/xnVdL26oTX3ibumno/8InMnJ5kOvHMXh1/guHHqoqC6hY+GgJBp2J2HVRlUeC4D5oXgtBMBWOU+iOS7FNkEdxS5WOJfcitH+kzj5u9jvwNNB4NRVVYVO+hYrFZ5PjaYxx4yifr5EwTMilwtgIRYF3S9vXAi6Ps/5F4KvmO+obG7vqGxm7gYuCL9Q2Nr2fonCU5SJfP4MWDZtfHxfNiBZsWfooBokQSWjTYhEoJ2ekjpPkE9o5RgoslOYtNhQ9VGFzgMoj2mjPvTrjDvBEorO+Xoios3uChZLbZZdmzP0LbttCYx0lyh4w98rY0N3nrGxofAO6ub2jcBRwFPg/MjaePU9/QeDcwp6W56Xbgc8A/Jf2Z3wEvA/8vU+ctyT2ad+im6qulTlg3JzeDVjPJaNabbLVocB8yTO8cKYVoeVZORTIJNAUaSw1Kg1a2i+FkN604ysODEBUKa3I3hCrlqJrC0nd52PHwAIGe4TnmyPMB3NUWSmYVTrzWdCTTNv3PAvcAm4Ai4A3g6pbmpqPx12fEBQ8tzU19QF/iwfUNjWFgoKW5aYRLS1IY7O802Nlmzo67dqUFawFNumORHH9TJbITbK1EBc5jZutNQHYNnzYoCrzTpXDQbyXoib69zVIW5pEuF0GXlcuyXxw7Y1jsKsuuL+LNX3nRI/FxLWBf8yBn3V6KzS0tk7lKRgVOS3MsGe6XAAAgAElEQVRTGPhM/N9or995muPfkbaTk+Q8hhD8Malb+JwyhbNnqfgHxzysYEi24FRnKf7GeUygJtwm3Q7BOiluphtzA3b2eIZT5q3lYSJdLpoDDixWnfWewolDcZRqLN7gYc/jwxNNNCDY+8Qgq24pll3IcxQpPSXThlePGLQPmCfVGwqwW/hYJFtwqrNhwRECd1LfqcB8FeQCMO2oTqpobCsbHl+PezW2+AvrnpYvsDHrAvN3arA1xskt6a8JJJkaUuBIpgXBqODPSWnha2erzCmXQxjATwy/Mnx9NKFQRuZbNNjbBRb/8O9ChcC8wloI84WapM7itnKzgH6kX+WtYGHd29kXOSmdY467Ob45iL9zgrWhJBlFrg6SacEze5LSwjUKPi08ka4k91SlcKBlIcDYfchsYQvWKRiOwloE84Uqv83UQ0zzxLDYhhdygcJvelX2hArn/iqqwqINHiwJGZvCgP1P+YbjcyQ5gxQ4kpyn2ydGpIW/Y7FGaYGnhSfSmRxgnIUO4pYBgb0rKTV8oZxipisWQ6XCb3ZT1c8JoibUZTVQ+EWPysFw4XwXbS6VhVe6TdsC3Trbft6ftXOSjI6cfSQ5zxM7Yqa08BInXL5Ypk0lkmzByUaBP/dBc+xNpAJipYWz8OUjNUlxOK6KMDd5QigJIieGws97VNrzv4XX21Qsso+odLzjYS+du2R9nFxCChxJTnOga2RaeMNKCzaLXDgTSbbgZDrAWAkLnMdlYb98IzkOp8MT5ix7jJtKzd/JsFB4sEejkJpuz7/cjc0zPMaFAS/e24MRk66qXEHOQJKcxRCCP741elq4ZJgQOl5lOEBJEZnvQeU+LEgooozuhNAMKUKnO9WjCByAC92Ca4vNasarKzzYrREya5+8xeJQWVRvdlX1H4my85GBrJ2TxIxcKSQ5y6tHDNqS0sKvl2nhI+hIck9V4MCaya+2LnAlpYb7F8rU8HygImBDM4bvo9+u47cNCZvLPIJ1bvN9b48p/LJXNbmU85nSuTaqlptF4Laf9xPoKpALkONIgSPJSQIRwZNJaeFnz1KZK9PCR9ChBEy/12TYPeU6JtASMtwMCwTmSnGTD2hCoTIp0LireLi68fUlBssdZpGzP6zyh36VQulHOe9SF5aETEE9LNj+s5hsyJkDyNVCkpO07NYJJKWFN6ySaeGj0Z5kwcmowBEC94Gkwn7zFIRVCpx8ITnQuLN4OJpYVeC2MoPZVvNivjWg8ldfYYwBq0tl7iUu07bONwTHXgyMeYwkM0iBI8k52rwGLx82+/ffuVSmhY9Fsouq1sicwBlR2E+RqeH5Rs1gUhxOiTldaqgLuU65ZhY5Tw6o7C6QQoDVK+1UrzRfp80/6CUaLJCApBxFzkSSnEIIweNvxTAS5spyF1y2SKaFj4aP6IgKxhUZrIHj2W+ewIOzFAwpRPOKGYPm8dRZHMXALGY8Gny4QseRUBlQoPCbPpWOAkgfVxSF9Z+pQEmYpgJdOjse9mbztAoeKXAkOcX2VoOD3UmBxastWDW5aI5GsnuqKoMVjK29AluveZt/kZxS8o2SkAVnZPi+xiyCbndkxH5VVri93DAVAgwLhZ/1aPgLIH28bL6Nle8uNm3b/tsBfB2yjUO2kLORJGeIxAQbk7qFL65WWDFDDtOxSA4wrhWuMfdNNcmxN+FqhViJFKL5hoIyworTVhQedd/FDsF1JeZx0asXTmbVWbeX4igdnq/0iGDL/X1ZPadCRq4ckpzhuf06/QkGCVWBG1bLtPDxSI6/yVSAseYXOFrNK5ZvkbxP+crMgSSBUzx2xd71bsH5LrPIORRRafbm/3Jjc6uc+zdlpm2HN/np2CkrHGeD/B9xkmlBX0CwaZ/Zjn3xAo2aYjlEx0IgsiZw3AcMkyMsWgyRKilw8pUZSYHGY1lwiKeP31hqMM9mFsAv+lXeCOT/GFl0jYfipDIJr/6gF2EUgAkrx5CrhyQn2Lg9Rizhoc9jh6uWy8Di8egnQjihfLBNqJRhG/eYVKCGBa5jSW0ZFqtDK5skL6ny2VATvp+Djhg+29ixJRYF7ijXKU3KrHqkP/97VqmawqoPmOeu7n0RDjztH/MYSXqQAkeSdQ50GWxvNZu0N6yw4JS1VMaldZQCf0oGAozdBw2UBGOb7oBgnbxX+YxFqCPaNoxnxSGeWXVHuY6WEHQcFQoP9Wjke/Z0xTKVeZeZ4+G2PtAn08YzjBQ4kqwSiQkee9P8JDirVOG8uXJono421SxwZmYgwFgNClyHkqw3i2RbhkJgpJvq9HEls2xD7qpEenSF3/ap5LvH5ryPl6FZh38P9ui89WuZNp5J5CoiySo/eiFCx6B5prtxjQVVujtOS7IFJxMCp2yzjpqgRw3bUOViSf4zYxKBxolcMErQ8Z6QyqbB/B43RbVWVt5aYtq283deBvPdR5dDSIEjyRrHeg3ufcZcT+O8OSpzK+SwPB0hYvQqwy4CRaQ/RVyJCMpfNFvb/AtVhCW/FyrJEDOTC/55IkS0iblcbig1mJXUzuHpQZW9ofweO2veV4KzfDgeR4/C6w/0Z/WcCgm5kkiyghCCrzwWIpTwMOOywnWy39SESLbeVODATnqDsste1bEkvK1hAf/8/F6gJMO4ohplgWGfi1CgdQJuKgBrPOjYrSZVOu5V6c3jOnhWl8q5Hyk1bTu0yU/nLpk2ngmkwJFkheadMZ7Za04Lv26VBbddLpgTIVng1Blptt7EBOUvmFeiwAIFYZP3q5CY5TVbcU6WTHyhLrUMNeZUEoKOg0LhoV6NaB7H4yyq91C+yJzd+OoP+2S38QwgBY4k4/jCgn963JyBMa9C4VwZWDxhkgXOjDS7p0q26lgHhn8XmmyqWYjUJcXhnJxgHM4pFjkE1xSb3VptUYVH+1Xydb1XVIUL7jIX/+vaFebIc7LbeLqRM5Qk43ynJUzbwPBspipw89kysHiixDBGFPhLZ4CxEhNU/iXJejNXwZDWtoKjLsmC01EUJqJOLvX5co9gpcN8zNaAymt5XARwxtlO5qw3F+Hccn8fsYhMG08nUuBIMsobx3Xuf9GcRXDZIo1aWbF4wnQqIfSErs0eYaE4jQX+Sl/TsSZktwoVfIvl/SpE3FELJf7hWC+hTDyb6hSKAreWGVRazCabx/pVjo/s4Zk3nPfxclO3cV97jN1Ng9k8pbxHzlKSjBGJCT77+5Cp/kVdqcJVy2TF4snQNiI93J2291Kigopk6808BcOZv0/bkvGZ2W8W05N1UwE4VPhAuY41QajrKPyyN387j5fMsrL8xiLTtjd/2U+oP08/cA4gBY4kY/zXpgh7Oswm2XtucmCTacaT4rjiM/2eTvdU2Ss61oSHTMMKviVy2ihkZvQlCZxJBBonUmOFW5KKAPbrCr/J4yKAZ99Ris0z/P2JBgTbfi7TxtOFnKkkGWFXm873Npntz7eutXDlMpkWPhl0DE4mWXBmG+mx4CgRQcVzZutN30UahkMK0kIm2YLT4Zl8HM4pznIJ1rvNx+4Pqzw9mJ9Lk71Y4+w7zMX/9m4cpP9oHvvmskhGV5f6hkYn8B3gVqAY2Al8saW56dkx9q8B7gE2AM74/l9paW76SybPW3JmxPQh11RiM80qj8I33uUY7zDJKLQrQaIJDTbdwkI59nGPmSrlL+tYEvoDGjboudRC0S5pUi9k3GGN0qCFfueQ+DXUISvO/L6pWRIbSgxORhWORoaF87ODKlf1wvrylJ12zrDsxmJ2/3GQwZND108Y8NqP+qj/dk22Ty3vyLRMvg+4CrgCqAR+DTxR39C4eIz9HwNqgLPjP58DNtY3NM7M8HlLzoAfPh/hrZPmp7R/u8lOmUtaAibLccXckXi2cKelwaYaFJT/1Wy96V2voXvkPZPAnH5zRtDR0uCY+54OiwK3l+t4VLNf6tt7oTUP6+FpVoXzP2ZOGz/xapCTW6Z+DSWjkzGBU9/QWA7cAXyppblpV0tzk7+luek/gN3AXaPsf8rC89mW5qb2luamUNya4wYuytR5S86MfZ06//602fx6wxoLDausYx4jGZvk+JvZhict71P5lxiWhPlWt0PPJdKdKBliTpK15ljZmdV0Kdbg/eU6akIRQJ8OX9sN4Tw0GM652EXNGrPl9dUf9mLoeRp8lCUyacFZG3eJvZa0/dXRBEtLc9NAS3PTR1qam/YkbF4Q/9ma3lOVpIJITPCp34QIJxgCylwK37ohPS6VfCeKQVtS/ZvZacigsvYZlL1kXlV6LrdgSIubJM4sr4PEsJt+Zwyv/cyaSC6ww4akIoAH/HDvQfKuCKCiKFxwl9n/1n8kyv4nfWMeI5k8mXwkq47/7Ena3g3Unu7guEXnQeCJluamzafbv7erHUPPjyJKsViU7vbpp+nufd7GjlazmPnSZQHwDdCd8D32DZy5NcfQdXwD3gnsOX05bg1iFA/P9MW6BXUgiI+JmbYNXSccOv2+tX8CVR8WM5EiQdu5UUS8cVgsj5shG0IQi+bxBzwN4djpx4dhGKiBMLVeG61lw9bZg54BVnrPLKPvAgscsTnYFRmeE/7cCYusAa6tyO1A3O724XTDCc3ZxTDrEpUTLwyvU1se6KFkxQCWAijDkMp1rbJ29KiVXLA5K8C4+ry+oXEusBHoBG6byB8trzqtZpo2dLe3jnkDc5WXDsb46evmyfKGNRY+eHkVSlLFYk8KMgh8A148xSUT2HP60q2ar+dciib1mX0DXuwO57j7OE4YlO0w34/ua2zYioZrFVms+dsdMRaNYrEWrvvUbhl/fACEQ0HsDifzvG6TwGmtirG25/THn4732uH7XYKu2PA88eNWF6srXSwrGvfQrFJZO3xyE52z138qxiOvnUQPDy2BkQE48YyL8z5adtpjpzuZWNcy6aJqj/+sStpenfDaCOobGs+Pu7FeBDa0NMvSj7lOf0Dwtw+HTGblmSUK99zkGCFuJBPnqJoUfyNSHH8jBNV/MlsvQjMUvGfnZ8qu5MyYmxRofLwkaKqwPVXs6lDncUfCsIsK+Noe6M8z45q7ysLq9xSbtu18xIv3RJ590CyRyZlrKxAB1iVtXx8XLyOob2hcBTwJfLuluemuluYmeddzHCEEX340RKt3eKJTFPiv9zgolTEcU2aACN3KcEqJIlIff1O0y8B92LxAdW6wDDULk0iSqPTbcEWGLXtRi6CtKDVpTzVW+FJSbm1nGL6xB1O5iXxg1XtKcFUMX0cjCq98v0d2G08BGRM4Lc1NXuAB4O76hsaV9Q2NnvqGxq8Dc+Pp49Q3NN5d39D4y/j/NeBnwH0tzU3fy9R5Ss6M370e47G3zC6MT15q5eKFueANnb4cVs2GyxnChTOFHmYlIqjZaH5+8C1W8S+WbTQko6OgjEgXP1yeug7ZV1TBLUkejG1e+P7hlL1FTmB1qpz/CbNL6uSWEMdelN3Gz5RMrzqfjad6bwKKgDeAq1uam47GX58RFzzELT1rgVX1DY1fSPo7D7U0N30sw+cuOQ2723W+9Kj5CW7VDJUvXi2zps6UQ4pZ4CwQqQ1GqNwUG9FQs/NaKUol4zO/18We6mHX6cGKAJccKU9Zbaa75sE+H7w1MLzt0TaY74IbZ6TkLXKC+Ve42btxkPa3wm9ve+W+XurOc2JxSBfxVMnoDNbS3BQGPhP/N9rrdyb8/4V4ALJkGjAQEnz0F0FCCUYAhwV+cJsDu+w1dUZE0DmRVOBvgZE6gWPrNKh4wZwW3rteI1wrJ1bJ+Mztc6LpCro25E4ZcMTockeo9qfmocaiwjeXwyfegI7htZ/vHYQ5TjinNCVvk3UUReGiv6vgsY+3IuIuOH+nzlu/9rL2w/kfcJwu5AwmOWOEEHzmdyEOdZt9xnff5GBJtXRxnClHFZ8peLNU2ChLVXsGIaj9YwwlQd9Ei6H7Smm9kZwem6GOcFMdqkita6XUCt9egSno2AC+vgdO5lHx37J5NlbcbA443v6wV/apOgOkwJGcMf/z1yh/2mmOu3n/+Vbed17hptumkkNJ8TfzjaKUuQCKthu4D5qjNjsarBh2aXWTTIxFPebaNwfK/WPuO1UWuuGrS83bBmLwlV0wmEdVC87+QCnOcnPA8Yv39iDytb16mpECR3JGvHQwxreeDJu2ra5TZbXiFGEgOJKm+BvNJ6j9Y1Jg8SKVwdVyWpBMnPl9LhKzw3vdUfocqU94vbQCPjLXvO1oEP5xF4TzJLPK5la54JPmCsedO8PsflxWR5kKciaTTJmjPQYf/1WIxIeLUifcf7sTh1VaAFLBCcVPMMF/ZBMqM1OUHl77eNTULVxo0HG9ZSivXyKZII6Yxiyvw7TtYEXqrTgAd8yCd1aat705AP+2D/LFyDH/HS5mX2R2+219oA9fRx6ZqjKEFDiSKdEfENz+0yA9fnO9m++/18mccjmsUsVutd/0+0JRjJYC91TRWzrFO8yPvd1XWIhUyXsnmTwLe8yie2+VDzF+gfopoSjwpSWw2hyqwqZu+OGRlL9dVlAUhXWfrsCaUDcsFhS89J+yNs5kkbOZZNJEYoKP/CLIwS7zAvm5d9q4cpkMTk0VMQwOKgOmbcuMM08b0QYFtY+bXQjBOoXuy2VAuGRqLOwxu6l63FG63OkJjrWr8K3lQ1lUiTx8En5/Mi1vmXHcVRbO+1hSbZzXghx4SjbjnAxS4EgmhRCCzz8S4qVD5rTixrMsfP4qW9bOKx85pAwSUYZFpEtYzrx6sRDMeDSKJSHRxdCg9RYraNI1JZka7qiFuX1mxbG7On2LcbEV7lkJ5Ul5DD84DE91pu1tM8rS64qoWWOOZdz8/V4GWmVB/4kiBY5kUtz7TITfbzP7gi+Yp/HdW2WfqVSzJ8k9tdQoQT1D91TZZp2i3UmuqassRGrkVCA5M5Z3moPf91b5UtKbaixmOIZEjjPB8CgYisf5S3fa3jZjKKrCxZ+rRLOZXVV//XYXRky6qiaCnNUkE+bBlyP8+9Nms/OCSoUHP+CUxfxSTJDYiOyp5WfonlJadWqazeI0MFuh51LpmpKcOfN7Xdijw0tKyGpwpCy97QYWe+Aby8zGRwP4l73wQk9a3zojlMyycsFdZldV154Ib/yif8xjJMNIgSOZEA+9EuErj5nTwctcCr+400W5W4qbVLNH7cdIuKxlwk4VjvEOGRcRMLA9FjYV9NPt0HqrVTbTlKQEi1BY0m12oe5Ko5vqFBeUwT8tNS9muoB/3gOv9Kb97dPO0uuLmL3O7P5761de2renprFpPiMFjuS0/GZLlC82mcWNwwI//aCD+ZVyCKUageAN1TwzLzdKplzcTxgC43d9KANms3bbu61E5f2TpJAVSW6qI+UBBuzpjxl5RyV8eYm5t09MwD/tgdf60v72aUVRFC75fKWpAKAw4LlvdxHs08c9ttCRs5tkXH6/LcrnHjE/Kdg0+MkHnVwwT2ZMpYMjig+vMuwK1ITCSqN83GPGw3h2ELHPLFB712sMrpKuKUlqqfbZqPAPR/4KBd6YOTDuMani6mr4+0XmbRED/mEXbOrKyCmkDUepxqVfMhcACnTpPPvPnehRGY8zFlLgSMbk4a1RPv1wiMTSC1YN7r/DyRVLpLhJF9tUc/DAElGCe4p9cY0tfsQms5sgMFuhY4O8f5LUo6BwTmuJadvOmkHCWmYsDdfVwqcXmLfFBHxzLzzWlpFTSBt15zpZ9R5zAaDOnWFe+UEeBBulCSlwJCMQQvCfz4b59O/MVYotKvzo/Q7ql8vFMV30EuKYahYkZ+sVU/pbxr4QxmNe07aYC07eZgMZFC5JE0u6PLgiw9bBqCbYUZu5VgONM+HvkkSOAL57EH5+DKZzrbxzP1LGzLXmWLy9G33s2ShbOYyGFDgSEzFd8KVHw9zzlDlbSlXgvvc5uHalbKCZTl5Pst7MMFzU4Bxz/7EQrVGMX/cNpZSc2maBEx+0ESuV4kaSPixCYU2bORbnjRkDaU0ZT+bmmfCVJSMXuJ8cg+8dgtg07V2lagqXf7UKT635IXPzf/dw8rU8aq2eIqTAkbxNIDJUofihV8xBgTZtyHJz/RopbtLJABF2JdW+OduYvPVGtEfRf9oDkYQFRYHo9XaCc+RXXpJ+VrcXY9GHhbTfrrOjJrNWhqur4VsrwJY05B9tg8/vgL70FFpOO44SjSu/WY3FMXx9hQ7P/HMnHTtkZlUicraTAHC81+CmHwV4arfZV17igN98xMm7Vktxk25e1bowEp5yS4SVRaJ43GOSEScj6Pd3g9/8iKo2FGPIuClJhnDGNJZ3ekzbXp3dR1jLrOlkXTn8+0pwJ8XTvzkAn3gT9k7TzgflC2xc+kVz0LEeFjz91Q56DoTHPK7QkAJHwl/2xbjm+362nzRPPjNLFB77pIt1C+TCmG56CLFTMeezXqBXT6qxpjgeQf9JDwTNrgDlYjfqes+Yx0kk6eCC46UmK07QZrC1LvMF6taUwH+tgRpz1wM6w/C3b8GTHRk/pZQw7zI3F37KnF0Z8Que+nIH/cemqXkqxUiBU8BEYoJ/aQ5x20+C9CUVHF1Rq/LEp1wsrZGpxOlGIHhOa0ckaJlSYWOZmHjlYmNvCP3BHggliZv1btRrJ2cFkkhSgTtqYe1Jc0bVtpkDDNpiYx6TLha64Udnwznm0yFiwL/th2/sgf5p2OJpRWMx59xpnidC/QbNn2mna7e05EiBU6Dsbtd51/8EuO+vI7/VG1ZYePQuF7XFcnhkgn3KwIjMqUv02glZb4QQGC/4MB7qhXCSuLnUjdpQLHuESbLG2pMlpowqXRNsWtiNIPOpTKVW+M4quGXmyNc2dcOHX4eXpmHl47NuL2HlreaHmPCAwZNfaOf45vS2ysh15ApWYISigv94Osw1/x0Y4ZJSFPiHa2w8cIeDIodcFDNBgBjPaeYCHXWGi4WiaMxjTiGiAuORfow/DZC8Xijv8KBeI8WNJLvYDJULj5ktDEfKg+ysyU7wi0WB/7tgKMMqOfi4Lwpf2QX37Jte1hxFUTj/42UsfZfZDR0LCZ75Wif7mgs3hVwKnAJBCMEze2O88z/9/PvTEaJJdbdmlij8/mNO/u4KO6rsTZQRBIKntZMElGGTvSoUrtRnnrYtgzgZQb+vC7EtKTVUGQoo1uqluJHkBis7ipgxYA6AeX5+D94MtHAYi6ur4UdnwRL3yNf+1Al3bIHfnYToNEknVxSFdZ+u4KzbzT44YcCL9/bw/P/rIhqcJh8mhUiBUwC8ciTGLf8b5I4HgxzuGWkavn61hac/7Wa9DCbOKFvUbg6p5qerC4wqysdpqiliAv3pAfQfdkNnUiyDQ0H9UDnqxTKgWJI7qCjU76/CmhBwHNUETyzrJJLhrKpE5rvhvrPgQ7NHLoQ+HX5weMht9WLP9CgOqCgKaz9cxkV/W07y89GBp/z88f+00nuosIKPpcDJY944ofP+nwS46YdBXjo0slR6pUfhf2938OPbnZS55NN+JtmveHlRNadv1BpOLjCqRt1fCIGxLzRktdnkMxXwA6DSgvbJKtTFU+84LpGki9KQlUsOmzN+uj0Rmpd2ZrQAYDIWFT48d0jozB2lnuaJEHx1N3zyTXiue6hLea6z/MZirvhaFZrNPKd7j8fY+KlWtv2sj1i4MKw58pE9z4jqgid3xvjp5uioooZ4rM2HLrTyxavtUthkgcPKIE9qJ0xPWXahca0+G3UU15RojWI86UUcHP3pS1nrRL2uBMUhn1ckucuqjiKOlgU5VDEc+HqsLEjL4i7q91ehiezNRcuK4MfnwB9a4aHjEEiaOvf44Ot7oM4B762Da6rBnsMJpvMudVNcZ+Uv/9qF99iwK1CPwhsPeTnQ4ueCT5YxZ70rr13ZUuDkCUd7DB5+PcovX43SMTj2Y8blizW+ssHOmroc/nbmMbuUPp7WWk0F/RQBDfpsSrC9vU0IgTgQRrzoR+wfI93To6I2lqIuk1YbSe6joHDNvioeWdVGZ9GwWN9X5Sdg1bluTzV2PXvzkl2F22YNiZcHj8ET7SMNpSdDcO9B+NERuKJyKJZndfHQQ2OuUb7AxvU/mMErP+hl/5PmoG5fe4xnv95F9Uo7q99XwuwLnSh5GHupiOngXJwaefPButtbqawdmdu4r1Pnie0xmnfE2NE2vsnxwnkaX7ralpNF+x565cz9wr4BL57ikgnsmR3C6DyvtbND7RvxWn2sjpWiDAAxoCO2BzG2BEbG2CSgnONEbShBcU3cauMb8HK45My7Ope+mvk6JpkiFo1isRZu1e46MUrUbRLhUBC7Y/L90U4RsOo8vLqVAad5HJUFrFy1v5IZviHBftH87M5Vh/xw/9HTp47PsMOVVXDru5ysna1h0ZQx5+xscWiTj1fv6yXYN/o6UTrPysp3FzPvMjc2d2YswSm+RqOqMylwpgGnBkKb1+ClQzovH9Z56WBs1IDhZC6cp/HZK21ctkjLWVNkPgscgeCAMsBftXYGlZFZI1fEalnTWTpkrdkZRByJjDtylQU21A3FKHW2sXcaAylwTo8UOOkXOAD9jiiPrmgfIXIQcFZbMeefKOWds+xjHZ5RjgTgtyegpQtip5lyS51w2WIL59UM8o7VFSysVHMmKzXiM9j28352PzqAGON5WLMpzFnvZME7Pcw4x4HVmT6xIwXOmTFtP5hhCNoGBLvaDHa06mw77Gdfr42jvRP7SG4b3LLWyocusrK8NvddUfkocELE2K8MsE3roVcZdjGpMahs06g9buHsY8UUHwS8ExAds62oVxShLLFPWahKgXN6pMDJjMABCFh0Ni7voL14pAtW0xXeGSrm8kAx86P205ZNyARd4aEYnSc7h2rmTIQSB5w9W2PtbI3ltSqLq1XmV6rYLdn7PH2HI7z2477Tdh9XrVC90kHdWgfVKx2UL7Kl1LqTdwKnvqHRCXwHuBUoBnYCX2xpbmno83cAAAjRSURBVHo2FfsnkZMCxzAEfUFB16Cgyxf/Nyho9Roc7REc6TU42mMQmuQaoihD1pqbzrLw7nOseOzZnxAmSj4InBA63UqIVuGnMxjAOxjCNaDgHlAp6VUp7dIo69Qo6VHR9AneGxWUlQ7U9R6UOZO32CQjBc7pkQIncwIHIKYa/GVBD7vGKfxXE7OyJuxiacTJvIidat2KJYuCJ2bAln74cye80APRSa40mgrzyhXmVajUlarUlSrMLFWZUaxQ7lYocw39S7cI6jkQZvtvBzjynH9Mi44JBUpmWSibb6N4lpXiOgvFM624KjQcZdqkrT35KHAeBNYBNwNHgbuAfwXWtDQ37T/T/ZNI6Qdr9RpsO64T1SESg3BMEIlBRIeIHv9/fHs4Br6wiP+DwbDAHxYMhqA3INBTlKFnUWH9Qo3rVlm4doWFqqLpmUWTSwJHHIsgfDrEGLJHJ/6LQpceJBbTicUERAyUoEANCawhsAdVnD5l4gJmLOqsqGucKKudKCWps8BJgXN6pMDJrMA5xbGSIM8u6mbAcfqxpQqo0q1Ux6wUGxpFhvb2zzlRG4ujqT238RiMwcu98EofvO5nRE+/M8Ft423B47YpOG3gtCq44j+dVnDahn7aLQpWbUg8WTWwqAoWbWiN0FSwqgqaBsUOhfPnmueUwdYo+570cegZH76Oqc8PFqeCs1zDWaphc6tYXQpWl4rVrWJ1qthcChVL7NSuGYqxyiuBU9/QWA50ALe0NDc9lrD9dWBTS3PT589k/1FI6Qd79M0on/x1KJV/ctJYVDhntsq6BRbWzdc4f66GexpZasYilwSO/pPuMdOx04YFlHl2lEV2lOUOlMr0BFdKgXN6pMDJjsABiKoGO2sGeb3Oi88+tXH6Dn8xH/fWpPzcJsKiBg9vnjDYtC/GS/sC7Oi0MJDdJWMEi6tV/vq50e+xMASdO8Mc2uTn5JYgg62p/56vuLmIC/9PBWRI4GQyTH1t/P1eS9r+KnBRCvZPK7YMh7IU2WFpjcrKmRpz3YNctKycpTUqLtv0FzQ5TSZ846UaSp0Vpc4Ks2woc2woVnlfJYWN1VA5u62E1e3FHKjw0z0nwJuOALFJFAIsMrIXc6ipCmvnaKydo/GhVT2UV8/gYLfB68cMdrTp7O802N9p0OrNbmHDsVBUhZrVDmpWD1lYBlujnNwapHNnmO59EbzHo2dsNkhn0PJoZFLgVMd/9iRt7wZqU7B/MildMRpWWWn7t2w92eV3nZMPXHjm8SUwegXgSXPhjNT8nZwkRdfogtT8Gcl0pSwD71E+gX1yl1OWicXVGourNd7L9LMKFs20smymlWXXp+fvZyKNPheCNpRJupMmu79EIpFIJJICI5MCpz3+M/kxsjrhtTPZXyKRSCQSiQQyLHC2ApF4VlQi64EXU7C/RCKRSCQSCWQhTfw+4Grgxnja9+eBLwArW5qbjtY3NN4NzGlpbrp9Ivtn7MQlEolEIpFMKzIdg/NZYCOwCegCNgBXJ4iVGcDcSewvkUgkEolEMoJ8btUgkUgkEomkQMmFLCqJRCKRSCSSlJLdfvSSTPfnmpZM4RodAeqA5HKoa1qam/Zl5qwzT31D43zgQeByYH5Lc9ORcfYtuHHE5K9RwY2j+obGGuCeeDiAMz4uvtLS3PSXMfYvuHE0hWtUUOOovqFxNfDteIKQDdgLfKuluenRMfZP2xiSFpzscx9wFXAFUAn8GniivqFxcYr2zwem8pk/1tLc5Ej6l3eTySnqGxobgc3xYPyJUHDjaArXiEIbR8BjQA1wdvznc8DG+obGsaqyFdw4msI1olDGUX1DoyceM3sAmB8v8/Io8Pv6hsYVYxyWtjEkLThZJN5v6454v61d8c3/Ud/QeHu8seho/bkmvH8+UIifeYqUA5cBs4EPjrdjAV/TCV+jQqS+ofHU0/N3Wpqb2uPb7gG+HG+P84ek/QtuHE32GhUgzvi1+FVLc1OAoevz3/Em2auAXYk7p3sMSYGTXaZ1f64MMdXPfGt9Q+OXgJnAfuCfW5qbNqb5XLNGS3PTAwxNGLMnsHshjqPJXqNTFMw4amluGgA+krR5Qfxn6yiHFNw4msI1OkVBjKOW5qYu4P5Tv9c3NFYC/wCcAEZzOaV1DEkXVXbJdH+u6chUPvNbwL642XM28DjweH1DY3LRyEKlEMfRVCjocRS3VjwIPNHS3LR5lF0KfhxN4BpRqOOovqExHC/vcjlQ39Lc1D3KbmkdQ9KCk5vI/lynZ8zP3NLcdEPSpm/WNzTeCHwceDkzpzctKcRxNCaFPI7qGxrnxmuQdQK3TfLwghhHE71GhTqOWpqb7HELzt8BL9U3NF40ibijlIwhacHJLrI/1+lJ1Wc+EC8kKSnMcZQq8n4c1Tc0nh93EbwIbGhpbhocY9eCHUeTuEZjkffjiCGR093S3PQ1oCMeU5NMWseQtOBkl8R+W79L2L4+/mRwpvvnA5P6zPE04C8C/9DS3NSf8NLKeHS/pDDH0aQo1HFU39C4CngS+GZLc9P3TrN7QY6jyVyjQhtH9Q2N1wE/BJa1NDf5E15SgNgoh6R1DEmBk0Vampu89Q2NDwB31zc07krotzU3njpHYn+uieyfb0z2GsVV//VAcX1D49/Gvzx/DywG3p3tz5MtCn0cTYRCH0f1DY0a8DPgvrEW7kIfR5O9RgU4jjbHa9/8d31D4+eBIPAJYNGpDLNMjiEpcLLPZ+NFozYBRcAbE+jPNd7++ciEr1FLc1OwvqHxqvj+++NPDm8B72hpbtqb3Y+RPuobGvfGr8Ept/Pe+oZGATzU0tz0MTmOJneNCnQcrYtntayqb2j8QtJrchwNMalrVGjjqKW5qae+obE+XuhvX1zs7AEaE4KwMzaGZC8qiUQikUgkeYcMMpZIJBKJRJJ3SIEjkUgkEokk75ACRyKRSCQSSd4hBY5EIpFIJJK8QwociUQikUgkeYcUOBKJRCKRSPIOKXAkEolEIpHkHVLgSCQSiUQiyTv+P4cNtfOK8HooAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 576x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "bento_obj_id": "139879162120992",
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "if not smoke_test:\n",
    "    plt.figure(figsize=(8, 5))\n",
    "    sns.distplot(lengthscale_samples, label=\"lengthscale\")\n",
    "    sns.distplot(outputscale_samples, label=\"outputscale\")\n",
    "    sns.distplot(period_length_samples[: int(num_samples / 2)], label=\"periodlength\")\n",
    "    plt.legend()\n",
    "    plt.title(\"Posterior Empirical Distribution\", fontsize=18)\n",
    "    plt.tight_layout()\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "originalKey": "98c61cf3-4e1b-4c92-a5f2-0c4d925af283",
    "showInput": false
   },
   "source": [
    "To generate predictions, we will convert our model to a Gpytorch model by running in `eval` mode. We load our posterior samples with a python dict, keyed on the parameter namespace and valued on the torch tensor of samples. Note the `unsqueeze`s to allow broadcasting of the data dimension to the right. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [],
   "source": [
    "gp.eval()  # converts to Gpytorch model in eval mode\n",
    "gp.bm_load_samples(\n",
    "    {\n",
    "        \"kernel.outputscale_prior\": outputscale_samples,\n",
    "        \"kernel.base_kernel.lengthscale_prior\": lengthscale_samples,\n",
    "        \"kernel.base_kernel.period_length_prior\": period_length_samples,\n",
    "        \"likelihood.noise_covar.noise_prior\": noise_samples,\n",
    "        \"mean.mean_prior\": mean_samples,\n",
    "    }\n",
    ")\n",
    "expanded_test_x = x_test.unsqueeze(0).repeat(num_samples, 1, 1)\n",
    "output = gp(expanded_test_x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "originalKey": "25a992f8-7b45-453f-9a46-d35f9919bfc1",
    "showInput": false
   },
   "source": [
    "Now we let's plot a few predictive samples from our GP. As you can see, we can draw different kernels, each of which paramaterizes a Multivariate Normal."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 576x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "bento_obj_id": "139891450278720",
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "if not smoke_test:\n",
    "    with torch.no_grad():\n",
    "        f, ax = plt.subplots(1, 1, figsize=(8, 5))\n",
    "        ax.plot(x_train.numpy(), y_train.numpy(), \"k*\", zorder=10)\n",
    "        ax.plot(\n",
    "            x_test.numpy(),\n",
    "            output.mean.median(0)[0].detach().numpy(),\n",
    "            \"b\",\n",
    "            linewidth=1.5,\n",
    "        )\n",
    "        for i in range(min(20, num_samples)):\n",
    "            ax.plot(\n",
    "                x_test.numpy(),\n",
    "                output.mean[i].detach().numpy(),\n",
    "                \"gray\",\n",
    "                linewidth=0.3,\n",
    "                alpha=0.8,\n",
    "            )\n",
    "        ax.legend([\"Observed Data\", \"Median\", \"Sampled Means\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "originalKey": "e4af262d-a240-4b09-88a8-3fa9e57e4317",
    "showInput": false
   },
   "source": [
    "## References\n",
    "[1] Rasmussen, Carl and Williams, Christopher. **Gaussian Processes for Machine Learning**. 2006."
   ]
  }
 ],
 "metadata": {
  "language_info": {
   "name": "python"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
